textus 0.54.2 → 0.55.1

data/lib/textus/action/key_mv.rb

@@ -2,9 +2,7 @@
 
 module Textus
   module Action
-    class KeyMv < WriteVerb
-      extend Textus::Contract::DSL
-
+    class KeyMv < Base
       verb :key_mv
       summary "Rename one entry (same zone + format). Refuses if the target exists. Single-key, lower blast radius than key_mv_prefix."
       surfaces :cli, :mcp
@@ -18,48 +16,40 @@ module Textus
                        "defaults to false, so omitting it applies the move immediately " \
                        "(unlike the bulk key_mv_prefix, which defaults to a dry-run plan)"
 
-      def initialize(old_key:, new_key:, dry_run: false)
-        super()
-        @old_key = old_key
-        @new_key = new_key
-        @dry_run = dry_run
+      def self.call(container:, call:, old_key:, new_key:, dry_run: false)
+        execute_move(container: container, call: call, old_key: old_key, new_key: new_key, dry_run: dry_run)
       end
 
-      def call(container:, call:)
-        run_with_cascade(cascade_target_key, container:, call:) do
-          execute_move(container, call)
-        end
-      end
+      def self.execute_move(container:, call:, old_key:, new_key:, dry_run:)
+        prepared = prepare(container: container, old_key: old_key, new_key: new_key)
+        return prepared if prepared.is_a?(Dry::Monads::Result::Failure)
 
-      private
-
-      def cascade_target_key
-        @dry_run ? nil : @new_key
-      end
-
-      def execute_move(container, call)
-        old_res, new_res = prepare(container, call)
-        return dry_run_result(container, old_res, new_res) if @dry_run
+        old_res, new_res = prepared
+        if dry_run
+          return Success(dry_run_result(container: container, old_key: old_key, new_key: new_key, old_res: old_res,
+                                        new_res: new_res))
+        end
 
-        envelope = apply_move(container, call, old_res, new_res)
-        success_result(old_res, new_res, envelope)
+        envelope = apply_move(container: container, call: call, old_key: old_key, new_key: new_key, old_res: old_res, new_res: new_res)
+        Success(success_result(old_key: old_key, new_key: new_key, old_res: old_res, new_res: new_res, envelope: envelope))
       end
 
-      def apply_move(container, call, old_res, new_res)
-        ensure_uid!(container, call, old_res.entry)
-        writer(container, call).move(
-          from_key: @old_key,
-          to_key: @new_key,
+      def self.apply_move(container:, call:, old_key:, new_key:, old_res:, new_res:)
+        ensure_uid!(container: container, call: call, old_key: old_key, old_mentry: old_res.entry)
+        container.compositor.move(
+          from_key: old_key,
+          to_key: new_key,
           new_mentry: new_res.entry,
+          call: call,
         )
       end
 
-      def success_result(old_res, new_res, envelope)
+      def self.success_result(old_key:, new_key:, old_res:, new_res:, envelope:)
         {
-          "protocol" => PROTOCOL,
+          "protocol" => Textus::PROTOCOL,
           "ok" => true,
-          "from_key" => @old_key,
-          "to_key" => @new_key,
+          "from_key" => old_key,
+          "to_key" => new_key,
           "from_path" => old_res.path,
           "to_path" => new_res.path,
           "uid" => envelope.uid,
@@ -67,58 +57,61 @@ module Textus
         }
       end
 
-      def prepare(container, call)
-        Textus::Manifest::Data.validate_key!(@old_key)
-        Textus::Manifest::Data.validate_key!(@new_key)
-        raise UsageError.new("mv: old and new keys are identical") if @old_key == @new_key
+      def self.prepare(container:, old_key:, new_key:)
+        Textus::Manifest::Data.validate_key!(old_key)
+        Textus::Manifest::Data.validate_key!(new_key)
+        return Failure(code: :usage_error, message: "mv: old and new keys are identical") if old_key == new_key
 
-        old_res = container.manifest.resolver.resolve(@old_key)
-        new_res = container.manifest.resolver.resolve(@new_key)
-        raise UnknownKey.new(@old_key) unless reader(container).exists?(@old_key)
+        old_res = container.manifest.resolver.resolve(old_key)
+        new_res = container.manifest.resolver.resolve(new_key)
+        return Failure(code: :not_found, message: "source key '#{old_key}' not found") unless container.compositor.exists?(old_key)
 
-        validate_zone_and_format!(old_res.entry, new_res.entry)
-        auth(container).check_action!(action: :key_mv, actor: call.role, key: @old_key)
-        auth(container).check_action!(action: :key_mv, actor: call.role, key: @new_key)
-        raise UsageError.new("mv: target '#{@new_key}' already exists at #{new_res.path}") if reader(container).exists?(@new_key)
+        zone_check = validate_zone_and_format(old_mentry: old_res.entry, new_mentry: new_res.entry)
+        return zone_check if zone_check.is_a?(Dry::Monads::Result::Failure)
+
+        if container.compositor.exists?(new_key)
+          return Failure(code: :usage_error, message: "mv: target '#{new_key}' already exists at #{new_res.path}")
+        end
 
         [old_res, new_res]
       end
 
-      def validate_zone_and_format!(old_mentry, new_mentry)
+      def self.validate_zone_and_format(old_mentry:, new_mentry:)
         if old_mentry.lane != new_mentry.lane
-          raise UsageError.new(
-            "mv: cross-zone move refused (#{old_mentry.lane} -> #{new_mentry.lane}). " \
-            "Use put+delete for cross-zone moves.",
-          )
+          return Failure(code: :usage_error,
+                         message: "mv: cross-zone move refused (#{old_mentry.lane} -> #{new_mentry.lane}). " \
+                                  "Use put+delete for cross-zone moves.")
         end
-        return if old_mentry.format == new_mentry.format
+        return unless old_mentry.format != new_mentry.format
 
-        raise UsageError.new("mv: format mismatch (#{old_mentry.format} -> #{new_mentry.format}); refusing.")
+        Failure(code: :usage_error,
+                message: "mv: format mismatch (#{old_mentry.format} -> #{new_mentry.format}); refusing.")
       end
 
-      def ensure_uid!(container, call, old_mentry)
-        pre_env = reader(container).read(@old_key)
+      def self.ensure_uid!(container:, call:, old_key:, old_mentry:)
+        pre_env = container.compositor.read(old_key)
         return if pre_env.uid
 
-        writer(container, call).put(
-          @old_key,
+        container.compositor.write(
+          old_key,
           mentry: old_mentry,
-          payload: Textus::Envelope::Writer::Payload.new(
+          payload: Textus::Store::Envelope::Writer::Payload.new(
             meta: pre_env.meta,
             body: pre_env.body,
             content: pre_env.content,
           ),
+          call: call,
         )
       end
 
-      def dry_run_result(container, old_res, new_res)
-        pre_env = reader(container).read(@old_key)
+      def self.dry_run_result(container:, old_key:, new_key:, old_res:, new_res:)
+        pre_env = container.compositor.read(old_key)
         {
-          "protocol" => PROTOCOL,
+          "protocol" => Textus::PROTOCOL,
           "ok" => true,
           "dry_run" => true,
-          "from_key" => @old_key,
-          "to_key" => @new_key,
+          "from_key" => old_key,
+          "to_key" => new_key,
           "from_path" => old_res.path,
           "to_path" => new_res.path,
           "uid" => pre_env.uid,

data/lib/textus/action/key_mv_prefix.rb

@@ -3,8 +3,6 @@
 module Textus
   module Action
     class KeyMvPrefix < Base
-      extend Textus::Contract::DSL
-
       verb :key_mv_prefix
       summary "Bulk-rename every leaf key under from_prefix to to_prefix. Dry-run returns a Plan; apply with dry_run: false."
       surfaces :cli, :mcp
@@ -18,39 +16,32 @@ module Textus
                                            "to false, so omitting it applies the rename immediately"
       view { |v, _i| v.to_h }
 
-      def initialize(from_prefix:, to_prefix:, dry_run: false)
-        super()
-        @from_prefix = from_prefix
-        @to_prefix = to_prefix
-        @dry_run = dry_run
-      end
-
-      def call(container:, call:)
-        raise UsageError.new("from_prefix and to_prefix required") if @from_prefix.nil? || @to_prefix.nil?
+      def self.call(container:, call:, from_prefix:, to_prefix:, dry_run: false)
+        return Failure(code: :usage_error, message: "from_prefix and to_prefix required") if from_prefix.nil? || to_prefix.nil?
 
-        leaves = Textus::Action::List.new(prefix: @from_prefix).call(container: container)
-                                     .map { |row| row.is_a?(Hash) ? (row["key"] || row[:key]) : row }
+        leaves = Textus::Action::List.leaf_keys(container: container, prefix: from_prefix)
 
-        if leaves.include?(@from_prefix)
-          raise UsageError.new("from_prefix '#{@from_prefix}' is itself a leaf — use `mv` to rename a single key")
+        if leaves.include?(from_prefix)
+          return Failure(code: :usage_error,
+                         message: "from_prefix '#{from_prefix}' is itself a leaf — use `mv` to rename a single key")
         end
 
         warnings = []
-        warnings << "no keys under #{@from_prefix}" if leaves.empty?
+        warnings << "no keys under #{from_prefix}" if leaves.empty?
 
         steps = leaves.map do |old_key|
-          tail = old_key.delete_prefix("#{@from_prefix}.")
-          new_key = "#{@to_prefix}.#{tail}"
+          tail = old_key.delete_prefix("#{from_prefix}.")
+          new_key = "#{to_prefix}.#{tail}"
           { "op" => "mv", "from" => old_key, "to" => new_key }
         end
 
-        plan = Textus::Jobs::Plan.new(steps: steps, warnings: warnings)
-        return plan if @dry_run
+        plan = Textus::Store::Jobs::Plan.new(steps: steps, warnings: warnings)
+        return Success(plan) if dry_run
 
         steps.each do |step|
-          Textus::Action::KeyMv.new(old_key: step["from"], new_key: step["to"]).call(container: container, call: call)
+          Value::Result.unwrap(Textus::Action::KeyMv.call(container: container, call: call, old_key: step["from"], new_key: step["to"]))
         end
-        plan
+        Success(plan)
       end
     end
   end

data/lib/textus/action/list.rb

@@ -3,8 +3,6 @@
 module Textus
   module Action
     class List < Base
-      extend Textus::Contract::DSL
-
       verb :list
       summary "List keys filtered by lane and/or prefix."
       surfaces :cli, :mcp
@@ -14,28 +12,16 @@ module Textus
           description: "restrict to one lane by name (see `boot` lanes); combine with prefix to narrow further"
       view(:cli) { |rows| { "entries" => rows } }
 
-      def initialize(prefix: nil, lane: nil)
-        super()
-        @prefix = prefix
-        @lane = lane
-      end
-
-      def call(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
+      def self.call(container:, call: nil, prefix: nil, lane: nil) # rubocop:disable Lint/UnusedMethodArgument
         manifest = container.manifest
-        rows = manifest.resolver.enumerate(prefix: @prefix)
-        rows = rows.select { |row| row[:manifest_entry].lane == @lane } if @lane
-        rows.map { |row| { "key" => row[:key], "lane" => row[:manifest_entry].lane, "path" => row[:path] } }
+        rows = manifest.resolver.enumerate(prefix: prefix)
+        rows = rows.select { |row| row[:manifest_entry].lane == lane } if lane
+        Success(rows.map { |row| { "key" => row[:key], "lane" => row[:manifest_entry].lane, "path" => row[:path] } })
       end
 
-      def self.new(*args, **kwargs)
-        return super(**kwargs) unless args.any?
-
-        call_spec = instance_method(:initialize).parameters
-        required = call_spec.slice(:keyreq).map(&:last)
-        optional = call_spec.slice(:key).map(&:last)
-        positional = required + optional
-        mapped = positional.zip(args).to_h
-        super(**mapped.merge(kwargs))
+      def self.leaf_keys(container:, prefix: nil, lane: nil)
+        rows = Value::Result.unwrap(call(container: container, prefix: prefix, lane: lane))
+        rows.map { |row| row.is_a?(Hash) ? (row["key"] || row[:key]) : row }
       end
     end
   end

data/lib/textus/action/propose.rb

@@ -2,9 +2,7 @@
 
 module Textus
   module Action
-    class Propose < WriteVerb
-      extend Textus::Contract::DSL
-
+    class Propose < Base
       verb :propose
       summary "Write a proposal to the role's propose_lane. Auto-prefixes the key."
       surfaces :cli, :mcp
@@ -19,33 +17,25 @@ module Textus
           description: "structured payload for json/yaml-format entries; omit (use `body`) for markdown entries. Do not send both"
       view { |env, _i| env.to_h_for_wire }
 
-      def initialize(key:, meta: nil, body: nil, content: nil)
-        super()
-        @key = key
-        @meta = meta
-        @body = body
-        @content = content
-      end
-
-      def call(container:, call:)
+      def self.call(container:, call:, key:, meta: nil, body: nil, content: nil)
         zone = container.manifest.policy.propose_lane_for(call.role)
         unless zone
-          raise Textus::Error.new(
-            "propose_forbidden",
-            "role '#{call.role}' has no writable propose_lane",
-            details: { "role" => call.role },
-            hint: "the manifest must define a queue zone and '#{call.role}' must hold the 'propose' capability",
-          )
+          return Failure(code: :propose_forbidden,
+                         message: "role '#{call.role}' has no writable propose_lane",
+                         details: { "role" => call.role })
         end
 
-        run_with_cascade("#{zone}.#{@key}", container:, call:) do
-          Textus::Action::Put.new(
-            key: "#{zone}.#{@key}",
-            meta: @meta || {},
-            body: @body,
-            content: @content,
-          ).call(container: container, call: call)
-        end
+        mentry = container.manifest.resolver.resolve("#{zone}.#{key}").entry
+        Success(container.compositor.write(
+                  "#{zone}.#{key}",
+                  mentry: mentry,
+                  payload: Textus::Store::Envelope::Writer::Payload.new(
+                    meta: meta || {},
+                    body: body,
+                    content: content,
+                  ),
+                  call: call,
+                ))
       end
     end
   end

data/lib/textus/action/published.rb

@@ -3,8 +3,6 @@
 module Textus
   module Action
     class Published < Base
-      extend Textus::Contract::DSL
-
       verb :published
       summary "List all entries that declare a publish_to target."
       surfaces :cli
@@ -14,10 +12,10 @@ module Textus
         {}
       end
 
-      def call(container:, **)
-        container.manifest.data.entries.reject { |entry| entry.publish_to.empty? }.map do |entry|
+      def self.call(container:, **)
+        Success(container.manifest.data.entries.reject { |entry| entry.publish_to.empty? }.map do |entry|
           { "key" => entry.key, "publish_to" => entry.publish_to }
-        end
+        end)
       end
     end
   end

data/lib/textus/action/pulse.rb

@@ -5,47 +5,40 @@ require "time"
 module Textus
   module Action
     class Pulse < Base
-      extend Textus::Contract::DSL
-
       verb :pulse
       summary "Delta since cursor — changed entries, pending proposals, index freshness."
       surfaces :cli, :mcp
-      around :cursor
       arg :since, Integer, session_default: :cursor,
                            description: "audit seq to diff from; defaults to the session cursor"
 
-      def initialize(since: nil)
-        super()
-        @since = since
-      end
+      def self.call(container:, call:, since: nil, **)
+        manifest = container.manifest
+        audit_log = container.audit_log
+        root = container.root
+        since ||= Textus::Store::Cursor.new(root: root, role: call.role).read
+
+        changed = Value::Result.unwrap(Textus::Action::Audit.call(container: container, seq_since: since))
 
-      def call(container:, call:)
-        @container = container
-        @call = call
-        @manifest = container.manifest
-        @audit_log = container.audit_log
-        @root = container.root
-
-        {
-          "cursor" => @audit_log.latest_seq,
-          "changed" => Textus::Action::Audit.new(seq_since: @since).call(container: container),
-          "pending_review" => review_keys,
-          "contract_etag" => Textus::Etag.for_contract(@root),
+        result = {
+          "cursor" => audit_log.latest_seq,
+          "changed" => changed,
+          "pending_review" => review_keys(manifest, container),
+          "contract_etag" => Textus::Value::Etag.for_contract(root),
           "index_etag" => index_etag(container),
         }
-      end
 
-      private
+        Textus::Store::Cursor.new(root: root, role: call.role).write(result["cursor"])
+        Success(result)
+      end
 
-      def review_keys
-        queue = @manifest.policy.queue_lane
+      def self.review_keys(manifest, container)
+        queue = manifest.policy.queue_lane
         return [] unless queue
 
-        rows = Textus::Action::List.new(lane: queue).call(container: @container)
-        rows.map { |row| row.is_a?(Hash) ? (row["key"] || row[:key]) : row }
+        Textus::Action::List.leaf_keys(container: container, lane: queue)
       end
 
-      def index_etag(container)
+      def self.index_etag(container)
         path = container.manifest.resolver.resolve("artifacts.system.index").path
         File.exist?(path) ? container.file_store.etag(path) : nil
       rescue Textus::Error

data/lib/textus/action/put.rb

@@ -2,9 +2,7 @@
 
 module Textus
   module Action
-    class Put < WriteVerb
-      extend Textus::Contract::DSL
-
+    class Put < Base
       verb :put
       summary "Create or update an entry. Schema-validated. Returns {uid, etag}."
       surfaces :cli, :mcp
@@ -20,32 +18,20 @@ module Textus
           description: "optimistic-concurrency guard: the etag you last read; the write is rejected if the entry changed since"
       view { |env| { "uid" => env.uid, "etag" => env.etag } }
 
-      def initialize(key:, meta: nil, body: nil, content: nil, if_etag: nil)
-        super()
-        @key = key
-        @meta = meta
-        @body = body
-        @content = content
-        @if_etag = if_etag
-      end
-
-      def call(container:, call:)
-        run_with_cascade(@key, container:, call:) do
-          Textus::Manifest::Data.validate_key!(@key)
-          mentry = container.manifest.resolver.resolve(@key).entry
-          envelope = writer(container, call).put(
-            @key,
-            mentry: mentry,
-            payload: Textus::Envelope::Writer::Payload.new(
-              meta: @meta,
-              body: @body,
-              content: @content,
-            ),
-            if_etag: @if_etag,
-          )
-
-          envelope
-        end
+      def self.call(container:, call:, key:, meta: nil, body: nil, content: nil, if_etag: nil) # rubocop:disable Metrics/ParameterLists
+        Textus::Manifest::Data.validate_key!(key)
+        mentry = container.manifest.resolver.resolve(key).entry
+        Success(container.compositor.write(
+                  key,
+                  mentry: mentry,
+                  payload: Textus::Store::Envelope::Writer::Payload.new(
+                    meta: meta,
+                    body: body,
+                    content: content,
+                  ),
+                  if_etag: if_etag,
+                  call: call,
+                ))
       end
     end
   end

data/lib/textus/action/rdeps.rb

@@ -3,36 +3,21 @@
 module Textus
   module Action
     class Rdeps < Base
-      extend Textus::Contract::DSL
-
       verb :rdeps
       summary "List the derived entries that depend on a key (reverse deps / impact set)."
       surfaces :cli, :mcp
       arg :key, String, required: true, positional: true,
                         description: "dotted key whose dependents (what would be stranded if it moved) you want"
 
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def call(container:, **)
+      def self.call(container:, key:, **)
         manifest = container.manifest
         rdeps = manifest.data.entries.each_with_object([]) do |entry, acc|
           next unless entry.external?
 
           sources = Array(entry.source&.sources).compact
-          acc << entry.key if sources.any? { |source| source == @key || @key.start_with?("#{source}.") }
+          acc << entry.key if sources.any? { |source| source == key || key.start_with?("#{source}.") }
         end
-        { "key" => @key, "rdeps" => rdeps }
-      end
-
-      def self.new(*args, **kwargs)
-        return super(**kwargs) unless args.any?
-
-        positional = instance_method(:initialize).parameters.slice(:keyreq, :key).map(&:last)
-        mapped = positional.zip(args).to_h
-        super(**mapped.merge(kwargs))
+        Success({ "key" => key, "rdeps" => rdeps })
       end
     end
   end

data/lib/textus/action/reject.rb

@@ -2,35 +2,26 @@
 
 module Textus
   module Action
-    class Reject < WriteVerb
-      extend Textus::Contract::DSL
-
+    class Reject < Base
       verb :reject
       summary "discard a queued proposal without applying it"
       surfaces :cli, :mcp
       cli "reject"
       arg :pending_key, String, required: true, positional: true, description: "the queued proposal's key"
 
-      def initialize(pending_key:)
-        super()
-        @pending_key = pending_key
-      end
-
-      def call(container:, call:)
-        run_with_cascade(@pending_key, container:, call:) do
-          mentry = container.manifest.resolver.resolve(@pending_key).entry
-          unless mentry.in_proposal_lane?(container.manifest.policy)
-            raise ProposalError.new("reject: '#{@pending_key}' is not in a proposal zone (zone=#{mentry.lane})")
-          end
-
-          env = Textus::Action::Get.new(key: @pending_key).call(container: container, call: call)
-          proposal = env.meta&.dig("proposal") or raise ProposalError.new("entry has no proposal block: #{@pending_key}")
-          target_key = proposal["target_key"] or raise ProposalError.new("proposal missing target_key")
+      def self.call(container:, call:, pending_key:)
+        mentry = container.manifest.resolver.resolve(pending_key).entry
+        unless mentry.in_proposal_lane?(container.manifest.policy)
+          return Failure(code: :proposal_error, message: "reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.lane})")
+        end
 
-          writer(container, call).delete(@pending_key, mentry: mentry)
+        env = container.compositor.read(pending_key)
+        parsed = proposal_from(env, key: pending_key)
+        return parsed if parsed.is_a?(Dry::Monads::Result::Failure)
 
-          { "protocol" => PROTOCOL, "rejected" => @pending_key, "target_key" => target_key }
-        end
+        target_key = parsed[:target_key]
+        container.compositor.delete(pending_key, mentry: mentry, call: call)
+        Success("protocol" => Textus::PROTOCOL, "rejected" => pending_key, "target_key" => target_key)
       end
     end
   end