textus 0.55.1 → 0.55.2

data/lib/textus/dispatch/middleware/audit_index.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Textus
+  module Dispatch
+    module Middleware
+      # Shadows successful write operations into the SQLite audit_events table
+      # synchronously after dispatch, without the command knowing. Read verbs
+      # and failed writes pass through unchanged.
+      class AuditIndex < Base
+        middleware_name :audit_index
+
+        INDEXED_CONTRACTS = [
+          Contracts::PutEntry,
+          Contracts::DeleteKey,
+          Contracts::MoveKey,
+        ].freeze
+
+        def initialize(job_store:, audit_log:)
+          super()
+          @job_store = job_store
+          @audit_log = audit_log
+        end
+
+        def call(container:, command:, call:, next_handler:) # rubocop:disable Lint/UnusedMethodArgument
+          result = next_handler.call(command, call)
+          return result unless result.success? && INDEXED_CONTRACTS.include?(command.class)
+
+          key = command.respond_to?(:key) ? command.key : nil
+          return result unless key
+
+          seq = @audit_log.latest_seq
+          verb = command.class.name.split("::").last
+                        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                        .downcase
+
+          @job_store.insert_audit_event(
+            seq: seq,
+            ts: Time.now.utc.iso8601,
+            role: call.role,
+            verb: verb,
+            key: key,
+            etag_before: nil,
+            etag_after: result.value.is_a?(Hash) ? result.value["etag"] : nil,
+          )
+          result
+        end
+      end
+    end
+  end
+end

data/lib/textus/dispatch/middleware/auth.rb

@@ -0,0 +1,40 @@
+module Textus
+  module Dispatch
+    module Middleware
+      class Auth < Base
+        middleware_name :auth
+
+        def call(container:, command:, call:, next_handler:)
+          verb = VerbRegistry.contract_to_verb!(command.class).to_sym
+          key = key_for(command)
+
+          rule_preds = key ? rule_declared_predicates(verb, container.manifest, key) : []
+
+          Manifest::Policy::Predicates.evaluate(
+            manifest: container.manifest, schemas: container.schemas,
+            action: verb, actor: call.role, key: key,
+            rule_predicates: rule_preds
+          )
+
+          next_handler.call(command, call)
+        end
+
+        private
+
+        def rule_declared_predicates(verb, manifest, key)
+          guard_map = manifest.rules.for(key).guard
+          return [] if guard_map.nil?
+
+          Array(guard_map[verb.to_s])
+        end
+
+        def key_for(command)
+          if command.respond_to?(:key) then command.key
+          elsif command.respond_to?(:old_key) then command.old_key
+          elsif command.respond_to?(:pending_key) then command.pending_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/textus/dispatch/middleware/base.rb

@@ -0,0 +1,26 @@
+module Textus
+  module Dispatch
+    module Middleware
+      class Base
+        def self.inherited(subclass)
+          super
+          subclass.instance_variable_set(:@middleware_name, nil)
+        end
+
+        class << self
+          def middleware_name(name = nil)
+            if name
+              @middleware_name = name.to_s
+            else
+              @middleware_name || name.split("::").last.downcase
+            end
+          end
+        end
+
+        def call(container:, command:, call:, next_handler:)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/textus/dispatch/middleware/binder.rb

@@ -0,0 +1,20 @@
+module Textus
+  module Dispatch
+    module Middleware
+      class Binder < Base
+        middleware_name :binder
+
+        def call(container:, command:, call:, next_handler:) # rubocop:disable Lint/UnusedMethodArgument
+          return next_handler.call(command, call) unless command.is_a?(Dispatch::Binder::Pending)
+
+          spec = command.spec
+          contract_class = VerbRegistry.contract_class_for(spec.verb) or
+            raise Textus::UsageError.new("unknown command verb: #{spec.verb}")
+          resolved = Dispatch::Binder.bind(spec, command.inputs)
+          built = Dispatch::Pipeline.build_command(contract_class, resolved)
+          next_handler.call(built, call)
+        end
+      end
+    end
+  end
+end

data/lib/textus/dispatch/middleware/cascade.rb

@@ -0,0 +1,53 @@
+module Textus
+  module Dispatch
+    module Middleware
+      class Cascade < Base
+        middleware_name :cascade
+
+        CASCADE_VERBS = %i[put propose accept reject key_mv key_delete].freeze
+
+        TRIGGER_TYPE_MAP = {
+          Contracts::PutEntry => "entry.written",
+          Contracts::ProposeEntry => "entry.written",
+          Contracts::DeleteKey => "entry.deleted",
+          Contracts::MoveKey => "entry.moved",
+          Contracts::AcceptProposal => "proposal.accepted",
+          Contracts::RejectProposal => "proposal.rejected",
+        }.freeze
+
+        def call(container:, command:, call:, next_handler:)
+          result = next_handler.call(command, call)
+          return result unless result.success? && cascadable?(command)
+
+          key = cascade_key(command)
+          return result unless key
+
+          trigger_type = TRIGGER_TYPE_MAP[command.class]
+          jobs = Textus::Store::Jobs::Planner.new(container: container).plan(
+            trigger: { "type" => trigger_type, "target" => key },
+            role: call.role,
+          )
+          queue = Textus::Store::Jobs::Queue.new(store: container.job_store)
+          jobs.each { |j| queue.enqueue(j) }
+          result
+        end
+
+        private
+
+        def cascadable?(command)
+          CASCADE_VERBS.include?(VerbRegistry.contract_to_verb!(command.class).to_sym)
+        end
+
+        def cascade_key(command)
+          case command
+          when Contracts::PutEntry, Contracts::DeleteKey then command.key
+          when Contracts::MoveKey                        then command.new_key
+          when Contracts::AcceptProposal,
+               Contracts::RejectProposal                 then command.pending_key
+          when Contracts::ProposeEntry                   then command.key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/textus/dispatch/pipeline.rb

@@ -0,0 +1,35 @@
+module Textus
+  module Dispatch
+    class Pipeline
+      attr_reader :container
+
+      def initialize(registry:, container:, middleware: [])
+        @registry = registry
+        @middleware = middleware
+        @container = container
+      end
+
+      def dispatch(command, call:)
+        stack = @middleware.reverse.reduce(->(cmd, c) { execute(cmd, c) }) do |next_mw, mw|
+          ->(cmd, c) { mw.call(container: @container, command: cmd, call: c, next_handler: next_mw) }
+        end
+        stack.call(command, call)
+      end
+
+      def self.build_command(contract_class, inputs)
+        members = contract_class.members
+        kwargs = members.to_h do |member|
+          [member, inputs[member]]
+        end
+        contract_class.new(**kwargs)
+      end
+
+      private
+
+      def execute(command, call)
+        handler = @registry.for(command.class)
+        handler.call(command, call)
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Textus
     class Check
       class AuditLog < Check
         def call
-          path = Textus::Store::Geometry.new(root).audit_log_path
+          path = Textus::Store::Layout.new(root).audit_log_path
           Textus::Port::AuditLog.new(root).verify_integrity.map do |v|
             {
               "code" => "audit.parse_error",

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

@@ -8,12 +8,12 @@ module Textus
       # verb reported.
       class GeneratorDrift < Check
         def call
-          gen = Textus::Core::Freshness::Evaluator.new(
+          detector = Textus::Store::Freshness::DriftDetector.new(
             manifest: manifest,
             file_stat: Textus::Port::Storage::FileStat.new,
             clock: Textus::Port::Clock.new,
           )
-          manifest.data.entries.flat_map { |m| gen.drift_rows(m) }.map do |row|
+          manifest.data.entries.flat_map { |m| detector.drift_rows(m) }.map do |row|
             {
               "code" => "generator_drift",
               "level" => "warning",

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

@@ -8,7 +8,7 @@ module Textus
       # that drift without making `build` scan globally.
       class OrphanedPublishTargets < Check
         def call
-          sdir = Textus::Store::Geometry.new(root).sentinels_root
+          sdir = Textus::Store::Layout.new(root).sentinels_root
           return [] unless File.directory?(sdir)
 
           repo_root = File.dirname(root)

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

@@ -4,7 +4,7 @@ module Textus
       class SchemaViolations < Check
         def call
           result = Textus::Doctor::Validator.new(
-            reader: ->(key, ctnr, c) { Value::Result.unwrap(Textus::Action::Get.call(container: ctnr, call: c, key: key)) },
+            reader: ->(key, ctnr, _c) { Textus::Store::Entry::Reader.from(container: ctnr).read(key) },
             manifest: @container.manifest,
             audit_log: @container.audit_log,
             schema_for: ->(name) { @container.schemas.fetch_or_nil(name) },

data/lib/textus/doctor/check/{notebook_sources.rb → scratchpad_sources.rb}

@@ -1,11 +1,11 @@
 module Textus
   module Doctor
     class Check
-      class NotebookSources < Check
+      class ScratchpadSources < Check
         def call
           issues = []
           manifest.resolver.enumerate.each do |row|
-            next unless row[:key].start_with?("notebook.notes.")
+            next unless row[:key].start_with?("scratchpad.notes.")
             next unless row[:path] && File.exist?(row[:path])
 
             sources = parse_sources(row[:path])
@@ -13,10 +13,10 @@ module Textus
               next if raw_entry_exists?(raw_key)
 
               issues << {
-                "code" => "notebook.source_missing",
+                "code" => "scratchpad.source_missing",
                 "level" => "warning",
                 "subject" => row[:key],
-                "message" => "notebook entry '#{row[:key]}' references raw key '#{raw_key}' " \
+                "message" => "scratchpad entry '#{row[:key]}' references raw key '#{raw_key}' " \
                              "which does not exist in the store",
                 "fix" => "re-ingest the source: textus ingest ..., or remove the stale sources: entry",
               }
@@ -33,7 +33,12 @@ module Textus
           return [] unless match
 
           front = YAML.safe_load(match[1])
-          Array(front&.dig("sources"))
+          Array(front&.dig("sources")).filter_map do |s|
+            case s
+            when String then s
+            when Hash   then s["key"]
+            end
+          end
         rescue StandardError
           []
         end

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

@@ -5,7 +5,7 @@ module Textus
         def call
           store      = Textus::Port::SentinelStore.new
           file_stat  = Textus::Port::Storage::FileStat.new
-          dir        = Textus::Store::Geometry.new(root).sentinels_root
+          dir        = Textus::Store::Layout.new(root).sentinels_root
           return [] unless file_stat.directory?(dir)
 
           repo_root = File.dirname(root)

data/lib/textus/doctor/check.rb

@@ -26,15 +26,17 @@ module Textus
       protected
 
       def root     = @container.root
-      def geometry = @container.geometry
+      def geometry = @container.layout
       def manifest = @container.manifest
 
-      # Dispatch a verb through Gate.
       def dispatch(verb, *args, **kwargs)
-        klass = Textus::Action::VERBS[verb]
-        spec = klass.contract if klass.respond_to?(:contract?) && klass.contract?
-        inputs = spec ? Textus::Gate::Binder.inputs_from_ordered(spec, args, kwargs) : kwargs
-        @container.gate.dispatch(spec:, inputs:, role: @role)
+        contract_class = Textus::VerbRegistry.contract_class_for(verb)
+        members = contract_class.members
+        command_kwargs = members.each_with_index.to_h { |m, i| [m, args[i] || kwargs[m]] }
+        command = contract_class.new(**command_kwargs)
+        call = Textus::Value::Call.build(role: @role)
+        result = @container.pipeline.dispatch(command, call: call)
+        Textus::Value::Result.extract(result)
       end
     end
   end

data/lib/textus/doctor.rb

@@ -22,7 +22,7 @@ module Textus
       Check::ProposalTargets,
       Check::GeneratorDrift,
       Check::RawAssetPaths,
-      Check::NotebookSources,
+      Check::ScratchpadSources,
       Check::StaleReviewedStamp,
     ].freeze
 

data/lib/textus/errors.rb

@@ -232,6 +232,8 @@ module Textus
   end
 
   class CursorExpired < Error
+    JSONRPC_CODE = -32_002
+
     attr_reader :requested, :min_available
 
     def initialize(requested:, min_available:)

data/lib/textus/format/base.rb

@@ -25,14 +25,46 @@ module Textus
         raise NotImplementedError.new("#{name}.nested_glob not implemented")
       end
 
-      def self.validate_path_extension(_path, _nested)
-        raise NotImplementedError.new("#{name}.validate_path_extension not implemented")
+      def self.validate_path_extension(path, nested)
+        ext = File.extname(path)
+        if nested
+          return if ext == ""
+
+          raise UsageError.new("#{format_name} nested path must not have an extension")
+        end
+
+        return if extensions.include?(ext)
+
+        raise UsageError.new("#{format_name} format requires '#{extensions.join("' or '")}' path (got #{ext.inspect})")
       end
 
-      def self.enforce_name_match!(_path, _meta)
-        raise NotImplementedError.new("#{name}.enforce_name_match! not implemented")
+      def self.enforce_name_match!(path, meta)
+        return unless meta.is_a?(Hash) && meta["name"]
+
+        ext = extensions.first
+        basename = File.basename(path, ext)
+        return if meta["name"] == basename
+
+        raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
       end
 
+      def self.rewrite_name(path, basename) # rubocop:disable Naming/PredicateMethod
+        raw = File.binread(path)
+        parsed = parse(raw, path: path)
+        meta = parsed["_meta"] || {}
+        return false unless meta.is_a?(Hash) && meta["name"].is_a?(String) && meta["name"] != basename
+
+        new_meta = meta.merge("name" => basename)
+        File.binwrite(path, serialize(meta: new_meta, body: parsed["body"] || "", content: parsed["content"]))
+        true
+      end
+
+      def self.format_name
+        name.split("::").last.downcase
+      end
+
+      def self.validate_raw_entry!(_parsed, _lane); end
+
       def self.serialize_for_put(meta:, body:, content:, path:)
         _ = meta
         _ = body
@@ -40,10 +72,6 @@ module Textus
         _ = path
         raise NotImplementedError.new("#{name}.serialize_for_put not implemented")
       end
-
-      def self.rewrite_name(_path, _basename)
-        raise NotImplementedError.new("#{name}.rewrite_name not implemented")
-      end
     end
   end
 end

data/lib/textus/format/json.rb

@@ -59,27 +59,6 @@ module Textus
         end
       end
 
-      def self.rewrite_name(path, basename) # rubocop:disable Naming/PredicateMethod
-        raw = File.binread(path)
-        parsed = parse(raw, path: path)
-        meta = parsed["_meta"]
-        return false unless meta.is_a?(Hash) && meta["name"].is_a?(String) && meta["name"] != basename
-
-        new_meta = meta.merge("name" => basename)
-        File.binwrite(path, serialize(meta: new_meta, body: "", content: parsed["content"]))
-        true
-      end
-
-      def self.enforce_name_match!(path, meta)
-        return unless meta.is_a?(Hash) && meta["name"]
-
-        ext = extensions.first
-        basename = File.basename(path, ext)
-        return if meta["name"] == basename
-
-        raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
-      end
-
       def self.validate_path_extension(path, nested)
         ext = File.extname(path)
         if nested

data/lib/textus/format/markdown.rb

@@ -43,27 +43,6 @@ module Textus
         [bytes, meta, body.to_s, nil]
       end
 
-      def self.rewrite_name(path, basename) # rubocop:disable Naming/PredicateMethod
-        raw = File.binread(path)
-        parsed = parse(raw, path: path)
-        meta = parsed["_meta"] || {}
-        return false unless meta.is_a?(Hash) && meta["name"].is_a?(String) && meta["name"] != basename
-
-        new_meta = meta.merge("name" => basename)
-        File.binwrite(path, serialize(meta: new_meta, body: parsed["body"]))
-        true
-      end
-
-      def self.enforce_name_match!(path, meta)
-        return unless meta.is_a?(Hash) && meta["name"]
-
-        ext = extensions.first
-        basename = File.basename(path, ext)
-        return if meta["name"] == basename
-
-        raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
-      end
-
       def self.validate_path_extension(path, _nested)
         ext = File.extname(path)
         return if ["", ".md"].include?(ext)

data/lib/textus/format/yaml.rb

@@ -82,27 +82,6 @@ module Textus
         end
       end
 
-      def self.rewrite_name(path, basename) # rubocop:disable Naming/PredicateMethod
-        raw = File.binread(path)
-        parsed = parse(raw, path: path)
-        meta = parsed["_meta"]
-        return false unless meta.is_a?(Hash) && meta["name"].is_a?(String) && meta["name"] != basename
-
-        new_meta = meta.merge("name" => basename)
-        File.binwrite(path, serialize(meta: new_meta, body: "", content: parsed["content"]))
-        true
-      end
-
-      def self.enforce_name_match!(path, meta)
-        return unless meta.is_a?(Hash) && meta["name"]
-
-        ext = extensions.first
-        basename = File.basename(path, ext)
-        return if meta["name"] == basename
-
-        raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
-      end
-
       def self.validate_path_extension(path, nested)
         ext = File.extname(path)
         if nested

data/lib/textus/format.rb

@@ -9,6 +9,18 @@ module Textus
       "text" => -> { Format::Text },
     }.freeze
 
+    # Optional registry for injectable format strategies. Tests or app
+    # initializers can set Format.registry = { "custom" => -> { MyFormat }}
+    @registry = nil
+
+    def self.registry=(reg)
+      @registry = reg
+    end
+
+    def self.registry
+      @registry
+    end
+
     EXT_TO_FORMAT = {
       ".md" => "markdown",
       ".json" => "json",
@@ -18,7 +30,10 @@ module Textus
     }.freeze
 
     def self.for(format)
-      STRATEGIES.fetch(format.to_s) { raise Textus::UsageError.new("unknown entry format: #{format.inspect}") }.call
+      key = format.to_s
+      return registry.fetch(key).call if registry&.key?(key)
+
+      STRATEGIES.fetch(key) { raise Textus::UsageError.new("unknown entry format: #{format.inspect}") }.call
     end
 
     def self.infer_from_extension(ext)

data/lib/textus/handlers/maintenance/boot_store.rb

@@ -0,0 +1,15 @@
+module Textus
+  module Handlers
+    module Maintenance
+      class BootStore
+        def initialize(container:)
+          @container = container
+        end
+
+        def call(_command, _call)
+          Value::Result.success(Textus::Boot.build(container: @container))
+        end
+      end
+    end
+  end
+end

data/lib/textus/handlers/maintenance/doctor_store.rb

@@ -0,0 +1,15 @@
+module Textus
+  module Handlers
+    module Maintenance
+      class DoctorStore
+        def initialize(container:)
+          @container = container
+        end
+
+        def call(command, call)
+          Value::Result.success(Textus::Doctor.build(container: @container, checks: command.checks, role: call.role))
+        end
+      end
+    end
+  end
+end

data/lib/textus/handlers/maintenance/drain_store.rb

@@ -0,0 +1,21 @@
+module Textus
+  module Handlers
+    module Maintenance
+      class DrainStore
+        def initialize(container:, job_store:)
+          @container = container
+          @job_store = job_store
+        end
+
+        def call(_command, call)
+          queue = Textus::Store::Jobs::Queue.new(store: @job_store)
+          Textus::Store::Jobs::Planner.seed(container: @container, queue: queue, role: call.role)
+          queue.reclaim(now: Textus::Port::Clock.new.now)
+          summary = Textus::Store::Jobs::Worker.for(container: @container, queue: queue).drain
+          Value::Result.success("protocol" => Textus::PROTOCOL, "ok" => summary.failed.zero?,
+                                "completed" => summary.completed, "failed" => summary.failed)
+        end
+      end
+    end
+  end
+end