textus 0.52.0 → 0.53.0

data/lib/textus/write/key_mv.rb

@@ -1,141 +0,0 @@
-module Textus
-  module Write
-    class KeyMv
-      extend Textus::Contract::DSL
-
-      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
-      cli      "key mv"
-      arg :old_key, String, required: true, positional: true,
-                            description: "current dotted key"
-      arg :new_key, String, required: true, positional: true,
-                            description: "new dotted key (must be the same zone and format as old_key)"
-      arg :dry_run, :boolean,
-          description: "when true, returns the planned move (from/to paths, uid) without applying it; " \
-                       "defaults to false, so omitting it applies the move immediately " \
-                       "(unlike the bulk key_mv_prefix, which defaults to a dry-run plan)"
-      # `call` already returns a wire hash; identity response.
-
-      def initialize(container:, call:)
-        @container    = container
-        @call         = call
-        @manifest     = container.manifest
-        @events       = container.events
-      end
-
-      def call(old_key, new_key, dry_run: false)
-        old_res, new_res = prepare(old_key, new_key)
-        return dry_run_result(old_key, new_key, old_res, new_res) if dry_run
-
-        ensure_uid!(old_key, old_res.entry)
-        envelope = writer.move(
-          from_key: old_key, to_key: new_key,
-          new_mentry: new_res.entry
-        )
-        publish_renamed(old_key, new_key, envelope)
-        success_result(old_key, new_key, old_res, new_res, envelope)
-      end
-
-      private
-
-      def hook_context
-        @hook_context ||= Textus::Hooks::Context.for(container: @container, call: @call)
-      end
-
-      def prepare(old_key, new_key)
-        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
-
-        old_res = @manifest.resolver.resolve(old_key)
-        new_res = @manifest.resolver.resolve(new_key)
-        raise UnknownKey.new(old_key) unless reader.exists?(old_key)
-
-        validate_zone_and_format!(old_res.entry, new_res.entry)
-        guard_for(:key_mv, old_key).check!(eval_for(:key_mv, target_key: old_key))
-        guard_for(:key_mv, new_key).check!(eval_for(:key_mv, target_key: new_key))
-        raise UsageError.new("mv: target '#{new_key}' already exists at #{new_res.path}") if reader.exists?(new_key)
-
-        [old_res, new_res]
-      end
-
-      def validate_zone_and_format!(old_mentry, new_mentry)
-        if old_mentry.zone != new_mentry.zone
-          raise UsageError.new(
-            "mv: cross-zone move refused (#{old_mentry.zone} → #{new_mentry.zone}). " \
-            "Use put+delete for cross-zone moves.",
-          )
-        end
-        return if old_mentry.format == new_mentry.format
-
-        raise UsageError.new("mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.")
-      end
-
-      # If the source file lacks a UID, rewrite it in-place via the writer
-      # so a UID gets injected before the move. This produces one "put"
-      # audit row, then the "mv" row from Writer#move.
-      def ensure_uid!(old_key, old_mentry)
-        pre_env = reader.read(old_key)
-        return if pre_env.uid
-
-        writer.put(
-          old_key, mentry: old_mentry,
-                   payload: Textus::Envelope::IO::Writer::Payload.new(
-                     meta: pre_env.meta, body: pre_env.body, content: pre_env.content,
-                   )
-        )
-      end
-
-      def publish_renamed(old_key, new_key, envelope)
-        @events.publish(:entry_renamed,
-                        ctx: hook_context,
-                        key: new_key,
-                        from_key: old_key,
-                        to_key: new_key,
-                        envelope: envelope)
-      end
-
-      def dry_run_result(old_key, new_key, old_res, new_res)
-        pre_env = reader.read(old_key)
-        {
-          "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
-          "from_key" => old_key, "to_key" => new_key,
-          "from_path" => old_res.path, "to_path" => new_res.path,
-          "uid" => pre_env.uid
-        }
-      end
-
-      def success_result(old_key, new_key, old_res, new_res, envelope)
-        {
-          "protocol" => PROTOCOL, "ok" => true,
-          "from_key" => old_key, "to_key" => new_key,
-          "from_path" => old_res.path, "to_path" => new_res.path,
-          "uid" => envelope.uid,
-          "envelope" => envelope.to_h_for_wire
-        }
-      end
-
-      def guard_for(transition, key, if_etag: nil)
-        Textus::Domain::Policy::GuardFactory.new(
-          manifest: @manifest, schemas: @container.schemas, extra: { if_etag: if_etag },
-        ).for(transition, key)
-      end
-
-      def eval_for(transition, target_key:, envelope: nil)
-        Textus::Domain::Policy::Evaluation.new(
-          actor: @call.role, transition: transition, origin: nil,
-          target: target_key, envelope: envelope, manifest: @manifest
-        )
-      end
-
-      def writer
-        @writer ||= Textus::Envelope::IO::Writer.from(container: @container, call: @call)
-      end
-
-      def reader
-        @reader ||= Textus::Envelope::IO::Reader.from(container: @container)
-      end
-    end
-  end
-end

data/lib/textus/write/propose.rb

@@ -1,54 +0,0 @@
-module Textus
-  module Write
-    # Queue a proposal: resolve the acting role's propose_zone, prefix the key,
-    # and write there via the Put verb. Was inlined in the MCP `propose` tool
-    # and the CLI propose verb; promoted to a first-class verb so all three
-    # transports share one implementation (ADR 0036, ADR 0039).
-    class Propose
-      extend Textus::Contract::DSL
-
-      verb     :propose
-      summary  "Write a proposal to the role's propose_zone. Auto-prefixes the key."
-      surfaces :cli, :mcp
-      cli_stdin :json
-      arg :key,     String, required: true, positional: true,
-                            description: "key relative to propose_zone, e.g. 'decisions.feature-x'"
-      arg :meta,    Hash,   required: false, wire_name: :_meta,
-                            description: "frontmatter; reads back as `_meta` from `get`. Include a 'proposal:' block naming the target_key"
-      arg :body,    String,
-          description: "markdown/text payload for markdown-format entries; omit (use `content`) for json/yaml entries. Do not send both"
-      arg :content, Hash,
-          description: "structured payload for json/yaml-format entries; omit (use `body`) for markdown entries. Do not send both"
-      # ADR 0069: every surface receives the raw Envelope and self-shapes — no
-      # surface pre-wires the result. Emitting the full wire envelope on every
-      # surface is a superset of the old `{uid, etag, key}` (the accepted
-      # breaking change; MCP/Ruby now get the full envelope too).
-      view { |env, _i| env.to_h_for_wire }
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-        @manifest  = container.manifest
-      end
-
-      # if_etag is intentionally absent: a proposal is always a fresh queue write.
-      def call(key, meta: nil, body: nil, content: nil)
-        zone = @manifest.policy.propose_zone_for(@call.role)
-        unless zone
-          raise Textus::Error.new(
-            "propose_forbidden",
-            "role '#{@call.role}' has no writable propose_zone",
-            details: { "role" => @call.role },
-            hint: "the manifest must define a queue zone and '#{@call.role}' must hold the 'propose' capability",
-          )
-        end
-
-        Textus::Dispatcher.invoke(
-          :put, container: @container, call: @call,
-                args: ["#{zone}.#{key}"],
-                kwargs: { meta: meta || {}, body: body, content: content }
-        )
-      end
-    end
-  end
-end

data/lib/textus/write/put.rb

@@ -1,74 +0,0 @@
-module Textus
-  module Write
-    class Put
-      extend Textus::Contract::DSL
-
-      verb     :put
-      summary  "Create or update an entry. Schema-validated. Returns {uid, etag}."
-      surfaces :cli, :mcp
-      arg :key,     String, required: true, positional: true,
-                            description: "dotted entry key, e.g. 'knowledge.project'; must resolve to a zone the role may write"
-      arg :meta,    Hash, required: false, wire_name: :_meta,
-                          description: "frontmatter; reads back as `_meta` from `get`. Schema-validated — call `schema KEY` first"
-      arg :body,    String,
-          description: "markdown/text payload for markdown-format entries; omit (use `content`) for json/yaml entries. Do not send both"
-      arg :content, Hash,
-          description: "structured payload for json/yaml-format entries; omit (use `body`) for markdown entries. Do not send both"
-      arg :if_etag, String,
-          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(container:, call:)
-        @container    = container
-        @call         = call
-        @manifest     = container.manifest
-        @events       = container.events
-      end
-
-      def call(key, meta: nil, body: nil, content: nil, if_etag: nil)
-        Textus::Manifest::Data.validate_key!(key)
-        mentry = @manifest.resolver.resolve(key).entry
-        guard_for(:put, key, if_etag: if_etag).check!(eval_for(:put, target_key: key))
-
-        envelope = writer.put(
-          key,
-          mentry: mentry,
-          payload: Textus::Envelope::IO::Writer::Payload.new(
-            meta: meta, body: body, content: content,
-          ),
-          if_etag: if_etag,
-        )
-
-        @events.publish(:entry_written,
-                        ctx: hook_context,
-                        key: key,
-                        envelope: envelope)
-
-        envelope
-      end
-
-      private
-
-      def guard_for(transition, key, if_etag: nil)
-        Textus::Domain::Policy::GuardFactory.new(
-          manifest: @manifest, schemas: @container.schemas, extra: { if_etag: if_etag },
-        ).for(transition, key)
-      end
-
-      def eval_for(transition, target_key:, envelope: nil)
-        Textus::Domain::Policy::Evaluation.new(
-          actor: @call.role, transition: transition, origin: nil,
-          target: target_key, envelope: envelope, manifest: @manifest
-        )
-      end
-
-      def hook_context
-        @hook_context ||= Textus::Hooks::Context.for(container: @container, call: @call)
-      end
-
-      def writer
-        @writer ||= Textus::Envelope::IO::Writer.from(container: @container, call: @call)
-      end
-    end
-  end
-end

data/lib/textus/write/reject.rb

@@ -1,68 +0,0 @@
-module Textus
-  module Write
-    class Reject
-      extend Textus::Contract::DSL
-
-      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(container:, call:)
-        @container    = container
-        @call         = call
-        @manifest     = container.manifest
-        @schemas      = container.schemas
-        @events       = container.events
-      end
-
-      def call(pending_key)
-        guard.for(:reject, pending_key).check!(
-          Textus::Domain::Policy::Evaluation.new(
-            actor: @call.role, transition: :reject, origin: pending_key,
-            target: pending_key, envelope: nil, manifest: @manifest
-          ),
-        )
-
-        mentry = @manifest.resolver.resolve(pending_key).entry
-        unless mentry.in_proposal_zone?(@manifest.policy)
-          raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})")
-        end
-
-        env = Textus::Read::Get.new(
-          container: @container, call: @call,
-        ).call(pending_key)
-        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")
-
-        delete_op.call(pending_key, suppress_events: true)
-
-        @events.publish(:proposal_rejected,
-                        ctx: hook_context,
-                        key: pending_key,
-                        target_key: target_key)
-
-        { "protocol" => PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
-      end
-
-      private
-
-      def guard
-        @guard ||= Textus::Domain::Policy::GuardFactory.new(manifest: @manifest, schemas: @schemas)
-      end
-
-      def hook_context
-        @hook_context ||= Textus::Hooks::Context.for(container: @container, call: @call)
-      end
-
-      def delete_op
-        @delete_op ||= Textus::Write::KeyDelete.new(
-          container: @container, call: @call,
-        )
-      end
-    end
-  end
-end