textus 0.15.0 → 0.20.0

data/lib/textus/application/reads/list.rb

@@ -2,12 +2,14 @@ module Textus
   module Application
     module Reads
       class List
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(prefix: nil, zone: nil)
-          @ctx.store.reader.list(prefix: prefix, zone: zone)
+          rows = @manifest.resolver.enumerate(prefix: prefix)
+          rows = rows.select { |r| r[:manifest_entry].zone == zone } if zone
+          rows.map { |row| { "key" => row[:key], "zone" => row[:manifest_entry].zone, "path" => row[:path] } }
         end
       end
     end

data/lib/textus/application/reads/policy_explain.rb

@@ -4,12 +4,12 @@ module Textus
       # For one key, surface every matching policy block along with the
       # per-slot effective value (which loses ties win-by-specificity).
       class PolicyExplain
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(key:)
-          policies = @ctx.store.manifest.rules
+          policies = @manifest.rules
           matching = policies.explain(key)
           winners  = policies.for(key)
 

data/lib/textus/application/reads/published.rb

@@ -2,12 +2,14 @@ module Textus
   module Application
     module Reads
       class Published
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call
-          @ctx.store.reader.published
+          @manifest.entries.reject { |e| e.publish_to.empty? }.map do |e|
+            { "key" => e.key, "publish_to" => e.publish_to }
+          end
         end
       end
     end

data/lib/textus/application/reads/rdeps.rb

@@ -2,12 +2,24 @@ module Textus
   module Application
     module Reads
       class Rdeps
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(key)
-          @ctx.store.reader.rdeps(key)
+          @manifest.entries.each_with_object([]) do |e, acc|
+            next unless e.is_a?(Textus::Manifest::Entry::Derived)
+
+            src = e.source
+            sources = if src.is_a?(Textus::Manifest::Entry::Derived::Projection)
+                        Array(src.select).compact
+                      elsif src.is_a?(Textus::Manifest::Entry::Derived::External)
+                        Array(src.sources).compact
+                      else
+                        []
+                      end
+            acc << e.key if sources.any? { |s| s == key || key.start_with?("#{s}.") }
+          end
         end
       end
     end

data/lib/textus/application/reads/schema_envelope.rb

@@ -2,12 +2,15 @@ module Textus
   module Application
     module Reads
       class SchemaEnvelope
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:, schemas:)
+          @manifest = manifest
+          @schemas = schemas
         end
 
         def call(key)
-          @ctx.store.reader.schema_envelope(key)
+          mentry = @manifest.resolver.resolve(key).entry
+          schema = @schemas.fetch_or_nil(mentry.schema)
+          { "protocol" => PROTOCOL, "key" => key, "schema_ref" => mentry.schema, "schema" => schema&.to_h }
         end
       end
     end

data/lib/textus/application/reads/stale.rb

@@ -2,12 +2,12 @@ module Textus
   module Application
     module Reads
       class Stale
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(prefix: nil, zone: nil)
-          @ctx.store.reader.stale(prefix: prefix, zone: zone)
+          Textus::Domain::Staleness.new(manifest: @manifest).call(prefix: prefix, zone: zone)
         end
       end
     end

data/lib/textus/application/reads/uid.rb

@@ -2,12 +2,20 @@ module Textus
   module Application
     module Reads
       class Uid
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(ctx:, manifest:, file_store:)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
         end
 
         def call(key)
-          @ctx.store.reader.uid(key)
+          get.get(key).uid
+        end
+
+        private
+
+        def get
+          @get ||= Get.new(ctx: @ctx, manifest: @manifest, file_store: @file_store)
         end
       end
     end

data/lib/textus/application/reads/validate_all.rb

@@ -2,12 +2,21 @@ module Textus
   module Application
     module Reads
       class ValidateAll
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(ctx:, manifest:, file_store:, schemas:, audit_log:)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
+          @schemas    = schemas
+          @audit_log  = audit_log
         end
 
         def call
-          @ctx.store.reader.validate_all
+          Validator.new(
+            reader: Get.new(ctx: @ctx, manifest: @manifest, file_store: @file_store),
+            manifest: @manifest,
+            audit_log: @audit_log,
+            schema_for: ->(name) { @schemas.fetch_or_nil(name) },
+          ).call
         end
       end
     end

data/lib/textus/application/reads/validator.rb

@@ -0,0 +1,84 @@
+module Textus
+  module Application
+    module Reads
+      class Validator
+        def initialize(reader:, manifest:, audit_log:, schema_for:)
+          @reader = reader
+          @manifest = manifest
+          @audit_log = audit_log
+          @schema_for = schema_for
+        end
+
+        def call
+          violations = []
+          check_content_violations(violations)
+          check_role_authority_violations(violations)
+          { "protocol" => PROTOCOL, "ok" => violations.empty?, "violations" => violations }
+        end
+
+        private
+
+        def check_content_violations(violations)
+          @manifest.resolver.enumerate.each do |row|
+            key = row[:key]
+            mentry = row[:manifest_entry]
+            env = fetch_envelope(key, violations) or next
+            schema = mentry.schema && @schema_for.call(mentry.schema)
+            next unless schema
+
+            begin
+              validate_schema!(schema, env, mentry.format)
+            rescue Textus::Error => e
+              violations << { "key" => key, "code" => e.code, "message" => e.message }
+            end
+          end
+        end
+
+        def check_role_authority_violations(violations)
+          @manifest.resolver.enumerate.each do |row|
+            mentry = row[:manifest_entry]
+            next unless mentry.schema
+
+            schema = @schema_for.call(mentry.schema)
+            next unless schema
+
+            env = begin
+              @reader.get(row[:key])
+            rescue StandardError
+              next
+            end
+            append_authority_violations(violations, row[:key], env, schema)
+          end
+        end
+
+        def append_authority_violations(violations, key, env, schema)
+          last_writer = @audit_log.last_writer_for(key)
+          return if last_writer.nil?
+
+          env.meta.each_key do |field|
+            owner = schema.maintained_by(field)
+            next if owner.nil? || last_writer == owner || last_writer == "human"
+
+            violations << { "key" => key, "code" => "role_authority",
+                            "field" => field, "expected" => owner, "last_writer" => last_writer }
+          end
+        end
+
+        def fetch_envelope(key, violations)
+          @reader.get(key)
+        rescue Textus::Error => e
+          violations << { "key" => key, "code" => e.code, "message" => e.message }
+          nil
+        end
+
+        def validate_schema!(schema, envelope, format)
+          payload = case format
+                    when "json", "yaml" then envelope.content || {}
+                    else envelope.meta || {}
+                    end
+          schema.validate!(payload)
+        end
+      end
+    end
+  end
+end

data/lib/textus/application/reads/where.rb

@@ -2,12 +2,15 @@ module Textus
   module Application
     module Reads
       class Where
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(key)
-          @ctx.store.reader.where(key)
+          res = @manifest.resolver.resolve(key)
+          mentry = res.entry
+          path = res.path
+          { "protocol" => PROTOCOL, "key" => key, "zone" => mentry.zone, "owner" => mentry.owner, "path" => path }
         end
       end
     end

data/lib/textus/application/refresh/all.rb

@@ -1,13 +1,24 @@
 module Textus
   module Application
     module Refresh
-      module All
-        module_function
+      class All
+        def initialize(ctx:, manifest:, envelope_io:, bus:, store:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @store        = store
+          @authorizer   = authorizer
+          @hook_context = hook_context
+        end
 
-        def call(ctx, prefix: nil, zone: nil)
-          worker = Textus::Application::Refresh::Worker.new(ctx: ctx, bus: ctx.store.bus)
+        def call(prefix: nil, zone: nil)
+          worker = Textus::Application::Refresh::Worker.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io, bus: @bus,
+            store: @store, authorizer: @authorizer, hook_context: @hook_context
+          )
 
-          stale_rows = Textus::Application::Reads::Stale.new(ctx: ctx).call(prefix: prefix, zone: zone)
+          stale_rows = Textus::Application::Reads::Stale.new(manifest: @manifest).call(prefix: prefix, zone: zone)
           refreshed = []
           failed = []
           skipped = []

data/lib/textus/application/refresh/orchestrator.rb

@@ -2,12 +2,13 @@ module Textus
   module Application
     module Refresh
       class Orchestrator
-        def initialize(worker:, bus:, store_root:, store: nil, role: "human", detached_spawner: nil)
-          @worker = worker
-          @bus = bus
-          @store_root = store_root
-          @store = store
-          @role = role
+        def initialize(worker:, store_root:, bus: nil, store: nil, ctx: nil, hook_context: nil, detached_spawner: nil) # rubocop:disable Metrics/ParameterLists
+          @worker       = worker
+          @store_root   = store_root
+          @bus          = bus
+          @store        = store
+          @ctx          = ctx
+          @hook_context = hook_context
           @detached_spawner = detached_spawner || default_spawner
         end
 
@@ -56,10 +57,9 @@ module Textus
 
             probe.release
 
-            store_view = @store ? Textus::Application::Context.new(store: @store, role: @role) : nil
             payload = { key: key, started_at: Time.now.utc.iso8601, budget_ms: budget_ms }
-            payload[:store] = store_view if store_view
-            @bus.publish(:refresh_backgrounded, **payload)
+            payload[:ctx] = @hook_context if @hook_context
+            @bus&.publish(:refresh_backgrounded, **payload)
             @detached_spawner.call(store_root: @store_root, key: key)
             Textus::Domain::Outcome::Detached.new
           elsif result.is_a?(Textus::Error)

data/lib/textus/application/refresh/worker.rb

@@ -6,14 +6,22 @@ module Textus
       class Worker
         FETCH_TIMEOUT_SECONDS = 30
 
-        def initialize(ctx:, bus:)
-          @ctx = ctx
-          @bus = bus
+        def initialize(ctx:, manifest:, envelope_io:, bus:, store:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @store        = store
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def run(key)
-          mentry, path, remaining = @ctx.store.manifest.resolve(key)
-          raise UsageError.new("no intake declared for '#{key}'") unless mentry.intake_handler
+          res = @manifest.resolver.resolve(key)
+          mentry = res.entry
+          path = res.path
+          remaining = res.remaining
+          raise UsageError.new("no intake declared for '#{key}'") unless mentry.is_a?(Textus::Manifest::Entry::Intake)
 
           before_etag = File.exist?(path) ? Etag.for_file(path) : nil
           result = fetch_with_bus(key, mentry, remaining)
@@ -22,19 +30,14 @@ module Textus
 
         private
 
-        def read_view
-          Application::Context.new(store: @ctx.store, role: @ctx.role)
-        end
-
         def fetch_timeout_for(key)
-          rule = @ctx.store.manifest.rules_for(key)
+          rule = @manifest.rules_for(key)
           rule&.refresh&.fetch_timeout_seconds || FETCH_TIMEOUT_SECONDS
         end
 
         def fetch_with_bus(key, mentry, remaining)
-          callable = @ctx.store.registry.rpc_callable(:resolve_intake, mentry.intake_handler)
-          @bus.publish(:refresh_started, store: read_view, key: key, mode: :sync,
-                                         correlation_id: @ctx.correlation_id)
+          callable = @bus.rpc_callable(:resolve_intake, mentry.handler)
+          @bus.publish(:refresh_started, ctx: @hook_context, key: key, mode: :sync)
           call_intake(key, mentry, callable, remaining)
         end
 
@@ -42,38 +45,38 @@ module Textus
           timeout = fetch_timeout_for(key)
           Timeout.timeout(timeout) do
             callable.call(
-              store: @ctx,
-              config: mentry.intake_config,
+              store: @store,
+              config: mentry.config,
               args: { trigger_key: key, leaf_segments: remaining || [] },
             )
           end
         rescue Timeout::Error
-          @bus.publish(:refresh_failed, store: read_view, key: key, error_class: "Timeout::Error",
-                                        error_message: "intake '#{mentry.intake_handler}' exceeded #{timeout}s",
-                                        correlation_id: @ctx.correlation_id)
-          raise UsageError.new("intake '#{mentry.intake_handler}' exceeded #{timeout}s timeout")
+          @bus.publish(:refresh_failed, ctx: @hook_context, key: key,
+                                        error_class: "Timeout::Error",
+                                        error_message: "intake '#{mentry.handler}' exceeded #{timeout}s")
+          raise UsageError.new("intake '#{mentry.handler}' exceeded #{timeout}s timeout")
         rescue Textus::Error => e
-          @bus.publish(:refresh_failed, store: read_view, key: key, error_class: e.class.name,
-                                        error_message: e.message, correlation_id: @ctx.correlation_id)
+          @bus.publish(:refresh_failed, ctx: @hook_context, key: key, error_class: e.class.name,
+                                        error_message: e.message)
           raise
         rescue StandardError => e
-          @bus.publish(:refresh_failed, store: read_view, key: key, error_class: e.class.name,
-                                        error_message: e.message, correlation_id: @ctx.correlation_id)
-          raise UsageError.new("intake '#{mentry.intake_handler}' raised: #{e.class}: #{e.message}")
+          @bus.publish(:refresh_failed, ctx: @hook_context, key: key, error_class: e.class.name,
+                                        error_message: e.message)
+          raise UsageError.new("intake '#{mentry.handler}' raised: #{e.class}: #{e.message}")
         end
 
         def persist_and_notify(key, mentry, result, before_etag)
-          normalized = Textus::Refresh.normalize_action_result(result, format: mentry.format)
-          envelope = Textus::Application::Writes::Put.new(ctx: @ctx, bus: @bus).call(
+          normalized = self.class.send(:normalize_action_result, result, format: mentry.format)
+          @authorizer.authorize_write!(mentry, role: @ctx.role)
+          envelope = @envelope_io.write(
             key,
-            meta: normalized[:meta], body: normalized[:body], content: normalized[:content],
-            suppress_events: true
+            mentry: mentry,
+            payload: Textus::Application::Writes::EnvelopeIO::Payload.new(
+              meta: normalized[:meta], body: normalized[:body], content: normalized[:content],
+            ),
           )
           change = detect_change(before_etag, envelope)
-          unless change == :unchanged
-            @bus.publish(:entry_refreshed, store: read_view, key: key, envelope: envelope, change: change,
-                                           correlation_id: @ctx.correlation_id)
-          end
+          @bus.publish(:entry_refreshed, ctx: @hook_context, key: key, envelope: envelope, change: change) unless change == :unchanged
           envelope
         end
 
@@ -83,6 +86,30 @@ module Textus
           else :updated
           end
         end
+
+        def self.normalize_action_result(res, format:)
+          res = res.transform_keys(&:to_s) if res.is_a?(Hash)
+          res ||= {}
+          meta_val = res["_meta"]
+          body     = res["body"]
+          content  = res["content"]
+
+          case format
+          when "markdown" then { meta: meta_val || {}, body: body.to_s, content: nil }
+          when "text"     then { meta: {}, body: body.to_s, content: nil }
+          when "json", "yaml"
+            if !content.nil?
+              { meta: meta_val || {}, body: nil, content: content }
+            elsif !body.nil?
+              { meta: {}, body: body.to_s, content: nil }
+            else
+              raise Textus::UsageError.new("intake for #{format} returned neither content nor body")
+            end
+          else
+            raise Textus::UsageError.new("unknown format #{format.inspect}")
+          end
+        end
+        private_class_method :normalize_action_result
       end
     end
   end

data/lib/textus/application/tools/migrate_keys.rb

@@ -0,0 +1,191 @@
+module Textus
+  module Application
+    module Tools
+      # Run-once helper that renames files/directories whose basenames don't
+      # conform to the strict key grammar (§3 of plan-1.2). Only walks
+      # nested: true manifest entries — leaf entries with illegal declared
+      # keys are caught by Manifest load and must be fixed by hand.
+      module MigrateKeys
+        SEGMENT = /\A[a-z0-9][a-z0-9-]*\z/
+
+        module_function
+
+        # Returns the envelope hash described in plan-1.2 §3.
+        def run(store, write: false)
+          plan = build_plan(store)
+          collisions = plan[:collisions]
+          renames = plan[:renames]
+
+          ok = collisions.empty?
+          apply!(store, renames) if write && ok
+
+          {
+            "protocol" => Textus::PROTOCOL,
+            "mode" => write ? "write" : "dry-run",
+            "renames" => renames.map { |r| envelope_rename(r) },
+            "collisions" => collisions.map { |c| envelope_collision(c) },
+            "ok" => ok,
+          }
+        end
+
+        # ------------------------------------------------------------------
+        # Plan construction
+        # ------------------------------------------------------------------
+
+        # Returns { renames: [...], collisions: [...] }
+        # Each rename: { from:, to:, old_key:, new_key:, kind: :file|:dir }
+        # Each collision: { target:, sources: [...] }
+        def build_plan(store) # rubocop:disable Metrics/AbcSize
+          renames = []
+          target_buckets = Hash.new { |h, k| h[k] = [] } # target_path => [source_path, ...]
+
+          store.manifest.entries.each do |entry|
+            next unless entry.nested?
+
+            base = File.join(store.root, "zones", entry.path)
+            next unless File.directory?(base)
+
+            # Walk depth-first. Order matters when computing the "new key"
+            # for files inside a renamed directory: we record renames bottom-up,
+            # so children are renamed before their parents on apply.
+            walk(base) do |abs_path, is_dir|
+              next if abs_path == base
+
+              basename = File.basename(abs_path)
+              stem = is_dir ? basename : basename.sub(/#{Regexp.escape(File.extname(basename))}\z/, "")
+              next if stem.match?(SEGMENT)
+
+              new_stem = normalize(stem)
+              # Skip if normalization yields the same stem (e.g. already-legal
+              # under a different lens). In practice match?(SEGMENT) catches that
+              # above; this is a safety net.
+              next if new_stem == stem
+
+              new_basename = is_dir ? new_stem : new_stem + File.extname(basename)
+              target = File.join(File.dirname(abs_path), new_basename)
+              target_buckets[target] << abs_path
+
+              renames << {
+                from: abs_path,
+                to: target,
+                kind: is_dir ? :dir : :file,
+                entry: entry,
+                base: base,
+              }
+            end
+          end
+
+          collisions = target_buckets.select { |_, srcs| srcs.length > 1 }
+                                     .map { |t, srcs| { target: t, sources: srcs.sort } }
+
+          # Drop colliding entries from renames (we won't apply any of them)
+          colliding_targets = collisions.to_set { |c| c[:target] }
+          renames.reject! { |r| colliding_targets.include?(r[:to]) }
+
+          # Sort renames bottom-up (deepest path first) so children move before parents.
+          renames.sort_by! { |r| -r[:from].count("/") }
+
+          { renames: renames, collisions: collisions }
+        end
+
+        # Yields [absolute_path, is_dir] for every entry under root. Depth-first.
+        def walk(root, &block)
+          Dir.each_child(root) do |name|
+            abs = File.join(root, name)
+            if File.directory?(abs)
+              walk(abs, &block)
+              yield abs, true
+            else
+              yield abs, false
+            end
+          end
+        end
+
+        # Deterministic transform per plan §3.
+        def normalize(s)
+          s = s.downcase
+          s = s.gsub(/[^a-z0-9-]/, "-") # ., _, and anything else become -
+          s = s.gsub(/-+/, "-")
+          s.sub(/\A-+/, "").sub(/-+\z/, "")
+        end
+
+        # ------------------------------------------------------------------
+        # Apply
+        # ------------------------------------------------------------------
+
+        def apply!(store, renames)
+          audit = Textus::Infra::AuditLog.new(store.root)
+          renames.each do |r|
+            # Bottom-up order means a child's ancestors haven't moved yet, so
+            # `from`/`to` are valid as-recorded. The audit `key` reflects the
+            # eventual full key once every rename in this batch has applied.
+            from = r[:from]
+            to = r[:to]
+            File.rename(from, to)
+            new_key = compute_new_key(r, renames)
+            audit.append(
+              role: "runner",
+              verb: "migrate-keys",
+              key: new_key,
+              etag_before: nil,
+              etag_after: nil,
+              extras: { "from" => from, "to" => to },
+            )
+          end
+        end
+
+        # If an ancestor of `path` was renamed earlier in this batch, rewrite the path.
+        def resolve_current_path(path, renames)
+          out = path
+          renames.each do |r|
+            prefix = r[:from] + "/"
+            out = r[:to] + out[r[:from].length..] if out.start_with?(prefix)
+          end
+          out
+        end
+
+        # New full key after applying all renames up through this one.
+        def compute_new_key(rename, renames)
+          base = rename[:base]
+          entry = rename[:entry]
+          new_to = resolve_current_path(rename[:to], renames)
+
+          rel = new_to.sub(%r{\A#{Regexp.escape(base)}/?}, "")
+          stripped = rel.sub(/#{Regexp.escape(File.extname(rel))}\z/, "") unless rename[:kind] == :dir
+          stripped ||= rel
+          segs = stripped.split("/").reject(&:empty?)
+          (entry.key.split(".") + segs).join(".")
+        end
+
+        # ------------------------------------------------------------------
+        # Envelope helpers
+        # ------------------------------------------------------------------
+
+        def envelope_rename(r)
+          {
+            "from" => r[:from],
+            "to" => r[:to],
+            "old_key" => path_to_key(r[:from], r[:base], r[:entry], r[:kind]),
+            "new_key" => path_to_key(r[:to], r[:base], r[:entry], r[:kind]),
+          }
+        end
+
+        def envelope_collision(col)
+          { "target" => col[:target], "sources" => col[:sources] }
+        end
+
+        def path_to_key(path, base, entry, kind)
+          rel = path.sub(%r{\A#{Regexp.escape(base)}/?}, "")
+          stripped =
+            if kind == :dir
+              rel
+            else
+              rel.sub(/#{Regexp.escape(File.extname(rel))}\z/, "")
+            end
+          segs = stripped.split("/").reject(&:empty?)
+          (entry.key.split(".") + segs).join(".")
+        end
+      end
+    end
+  end
+end