textus 0.55.2 → 0.56.0

data/lib/textus/store/jobs/retention/base.rb

@@ -1,52 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    module Jobs
-      module Retention
-        class Base
-          def initialize(container:, call:)
-            @container = container
-            @call = call
-          end
-
-          def call(rows)
-            out = { dropped: [], archived: [], failed: [] }
-            rows.each do |row|
-              key = row["key"]
-              begin
-                case row["action"]
-                when "drop"
-                  delete(key)
-                  out[:dropped] << key
-                when "archive"
-                  archive_leaf(row)
-                  delete(key)
-                  out[:archived] << key
-                end
-              rescue Textus::Error => e
-                out[:failed] << { "key" => key, "error" => e.message }
-              end
-            end
-            out
-          end
-
-          private
-
-          def archive_leaf(row)
-            src  = row["path"]
-            dest = @container.layout.archive_path(src)
-            FileUtils.mkdir_p(File.dirname(dest))
-            FileUtils.cp(src, dest)
-          end
-
-          def delete(key)
-            mentry = @container.manifest.resolver.resolve(key).entry
-            writer = Textus::Store::Entry::Writer.from(container: @container, call: @call)
-            writer.delete(key, mentry: mentry)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/store/jobs/retention/sweep.rb

@@ -1,55 +0,0 @@
-require "time"
-
-module Textus
-  class Store
-    module Jobs
-      module Retention
-        class Sweep
-          def self.expired?(ttl_seconds:, mtime:, now:)
-            return false if ttl_seconds.nil? || mtime.nil?
-
-            (now - mtime).to_i > ttl_seconds
-          end
-
-          def initialize(manifest:, file_stat:, clock:)
-            @manifest = manifest
-            @file_stat = file_stat
-            @clock = clock
-          end
-
-          def call(prefix: nil, lane: nil)
-            @manifest.data.entries
-                     .select { |m| matches?(m, prefix: prefix, lane: lane) }
-                     .flat_map { |m| rows_for(m) }
-          end
-
-          private
-
-          def matches?(mentry, prefix:, lane:)
-            return false if lane && mentry.lane != lane
-            return false if prefix && !Textus::Key::Matching.matches_prefix?(
-              mentry.key, prefix, nested: mentry.is_a?(Textus::Manifest::Entry::Nested)
-            )
-
-            true
-          end
-
-          def rows_for(mentry)
-            policy = @manifest.rules.for(mentry.key).retention
-            return [] if policy.nil?
-
-            @manifest.resolver.enumerate(prefix: mentry.key).filter_map do |row|
-              path = row[:path]
-              next unless @file_stat.exists?(path)
-              next unless self.class.expired?(
-                ttl_seconds: policy.ttl_seconds, mtime: @file_stat.mtime(path), now: @clock.now,
-              )
-
-              { "key" => row[:key], "path" => path, "action" => policy.action.to_s }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/store/jobs/retention.rb

@@ -1,8 +0,0 @@
-module Textus
-  class Store
-    module Jobs
-      module Retention
-      end
-    end
-  end
-end

data/lib/textus/store/jobs/sweep.rb

@@ -1,21 +0,0 @@
-module Textus
-  class Store
-    module Jobs
-      class Sweep < Base
-        REQUIRED_ROLE = Textus::Value::Role::AUTOMATION
-        TYPE = "sweep"
-
-        def self.call(container:, call:, scope: {}, key: nil)
-          prefix = key || (scope.is_a?(Hash) ? scope["prefix"] : nil)
-          lane   = scope.is_a?(Hash) ? scope["lane"] : nil
-          rows = Retention::Sweep.new(
-            manifest: container.manifest,
-            file_stat: Textus::Port::Storage::FileStat.new,
-            clock: Textus::Port::Clock.new,
-          ).call(prefix: prefix, lane: lane)
-          Retention::Base.new(container: container, call: call).call(rows)
-        end
-      end
-    end
-  end
-end

data/lib/textus/store/jobs/worker.rb

@@ -1,64 +0,0 @@
-module Textus
-  class Store
-    module Jobs
-      class Worker
-        Summary = Struct.new(:completed, :failed, keyword_init: true)
-
-        def self.for(container:, queue:)
-          new(queue: queue, container: container,
-              lease_ttl: container.manifest.data.worker_config[:lease_ttl])
-        end
-
-        def initialize(queue:, container:, lease_ttl: 60)
-          @queue     = queue
-          @container = container
-          @lease_ttl = lease_ttl
-        end
-
-        def drain(worker_id: "drain-#{Process.pid}")
-          completed = 0
-          failed    = 0
-          loop do
-            leased = @queue.lease(worker_id: worker_id, lease_ttl: @lease_ttl)
-            break unless leased
-
-            case run_one(leased)
-            when :completed     then completed += 1
-            when :dead_lettered then failed += 1
-            end
-          end
-          Summary.new(completed: completed, failed: failed)
-        end
-
-        def drain_pool(pool: 4)
-          summaries = []
-          mutex     = Mutex.new
-          threads   = Array.new(pool) do |i|
-            Thread.new do
-              s = drain(worker_id: "pool-#{Process.pid}-#{i}")
-              mutex.synchronize { summaries << s }
-            end
-          end
-          threads.each(&:join)
-          Summary.new(completed: summaries.sum(&:completed), failed: summaries.sum(&:failed))
-        end
-
-        private
-
-        def run_one(leased)
-          job    = leased.job
-          klass  = Textus::Jobs.fetch(job.type)
-          call   = Textus::Value::Call.build(
-            role: job.role || Textus::Value::Role::AUTOMATION,
-            correlation_id: SecureRandom.uuid,
-          )
-          klass.call(container: @container, call: call, **job.args.transform_keys(&:to_sym))
-          @queue.ack(leased)
-          :completed
-        rescue StandardError => e
-          @queue.fail(leased, error: e.message)
-        end
-      end
-    end
-  end
-end

data/lib/textus/store.rb

@@ -1,122 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    attr_reader :container, :role, :correlation_id, :cursor, :propose_lane, :contract_etag
-
-    Textus::Store::Container.attribute_names.each do |field|
-      define_method(field) { @container.public_send(field) }
-    end
-
-    def self.discover(start_dir = Dir.pwd, root: nil)
-      explicit = root || ENV.fetch("TEXTUS_ROOT", nil)
-      return discover_explicit(explicit) if explicit
-
-      ascend_for_store(File.expand_path(start_dir)) ||
-        raise(IoError.new("no .textus directory found from #{start_dir}"))
-    end
-
-    private_class_method def self.ascend_for_store(dir)
-      loop do
-        candidate = File.join(dir, ".textus")
-        return new(candidate) if store_dir?(candidate)
-
-        parent = File.dirname(dir)
-        return nil if parent == dir
-
-        dir = parent
-      end
-    end
-
-    private_class_method def self.discover_explicit(root_arg)
-      abs = File.expand_path(root_arg)
-      raise IoError.new("no textus store at #{abs}") unless store_dir?(abs)
-
-      new(abs)
-    end
-
-    private_class_method def self.store_dir?(dir)
-      File.directory?(dir) && File.exist?(File.join(dir, "manifest.yaml"))
-    end
-
-    def initialize(root, role: Value::Role::DEFAULT, correlation_id: nil, dry_run: false, container: nil)
-      @root = File.expand_path(root)
-      @container = container || build_container(@root)
-      @role = role.to_s
-      @correlation_id = correlation_id || SecureRandom.uuid
-      @dry_run = dry_run
-      build_session!
-    end
-
-    def dry_run? = @dry_run
-
-    def with_role(new_role)
-      _rebuild(role: new_role)
-    end
-
-    def with_correlation_id(cid)
-      _rebuild(correlation_id: cid)
-    end
-
-    def advance_cursor(new_cursor)
-      dup.tap do |s|
-        s.instance_variable_set(:@cursor, new_cursor)
-      end
-    end
-
-    def check_etag!(observed_etag)
-      return if observed_etag == @contract_etag
-
-      raise Textus::ContractDrift.new(
-        "contract changed (manifest/hooks/schemas were #{short_etag(@contract_etag)}, " \
-        "now #{short_etag(observed_etag)}); re-run boot",
-      )
-    end
-
-    private
-
-    def _rebuild(role: @role, correlation_id: @correlation_id, dry_run: @dry_run)
-      self.class.allocate.tap do |s|
-        s.instance_variable_set(:@root, @root)
-        s.instance_variable_set(:@container, @container)
-        s.instance_variable_set(:@role, role.to_s)
-        s.instance_variable_set(:@correlation_id, correlation_id || SecureRandom.uuid)
-        s.instance_variable_set(:@dry_run, dry_run)
-        s.send(:build_session!)
-      end
-    end
-
-    def build_session!
-      @cursor = @container.audit_log.latest_seq
-      @propose_lane = @container.manifest.policy.propose_lane_for(@role)
-      @contract_etag = Value::Etag.for_contract(@root)
-    end
-
-    def short_etag(etag) = etag.to_s.delete_prefix("sha256:")[0, 8]
-
-    def build_container(root)
-      manifest = Manifest.load(root)
-      job_store = Port::Store.new(root: root).setup!
-      layout = Store::Layout.new(root)
-      infra = Container::Infrastructure.new(
-        file_store: Port::Storage::FileStore.new,
-        schemas: Schema::Registry.new(layout.schemas_dir),
-        audit_log: Port::AuditLog.new(
-          layout: layout,
-          max_size: manifest.data.audit_config[:max_size],
-          keep: manifest.data.audit_config[:keep],
-        ),
-        job_store:,
-        layout:,
-      )
-
-      coord_seed = Container::Coordination.new(
-        manifest:,
-        workflows: Workflow::Loader.load_all(root),
-        pipeline: nil,
-      )
-
-      Container.build(infra, coord_seed)
-    end
-  end
-end

data/lib/textus/surface/cli/verb/doctor.rb

@@ -1,20 +0,0 @@
-module Textus
-  module Surface
-    class CLI
-      class Verb
-        class Doctor < Verb
-          command_name "doctor"
-          option :checks, "--check=NAME"
-
-          def call(store)
-            Textus::VerbRegistry.for(:doctor)
-            inputs = { checks: checks&.split(",")&.map(&:strip) }
-            s = store.with_role(resolved_role(store))
-            res = s.doctor(**inputs)
-            emit(res, exit_code: res["ok"] ? 0 : 1)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/surface/cli/verb/schema_diff.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Surface
-    class CLI
-      class Verb
-        class SchemaDiff < Verb
-          command_name "diff"
-          parent_group Group::Schema
-
-          def call(store)
-            name = positional.shift or raise UsageError.new("schema diff NAME")
-            emit(Textus::Schema::Tools.diff(store, name: name))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/surface/cli/verb/schema_init.rb

@@ -1,21 +0,0 @@
-module Textus
-  module Surface
-    class CLI
-      class Verb
-        class SchemaInit < Verb
-          command_name "init"
-          parent_group Group::Schema
-
-          option :from_key, "--from=KEY"
-
-          def call(store)
-            name = positional.shift or raise UsageError.new("schema init NAME")
-            raise UsageError.new("schema init requires --from=KEY") unless from_key
-
-            emit(Textus::Schema::Tools.init(store, name: name, from: from_key))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/surface/cli/verb/schema_migrate.rb

@@ -1,21 +0,0 @@
-module Textus
-  module Surface
-    class CLI
-      class Verb
-        class SchemaMigrate < Verb
-          command_name "migrate"
-          parent_group Group::Schema
-
-          option :rename, "--rename=O:N"
-
-          def call(store)
-            name = positional.shift or raise UsageError.new("schema migrate NAME")
-            raise UsageError.new("schema migrate requires --rename=OLD:NEW") unless rename
-
-            emit(Textus::Schema::Tools.migrate(store, name: name, rename: rename))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/surface/mcp/projector.rb

@@ -1,20 +0,0 @@
-module Textus
-  module Surface
-    module MCP
-      class Projector
-        def initialize(view_key: :default)
-          @view_key = view_key
-        end
-
-        def dispatch(verb_name, inputs:, store:)
-          spec = VerbRegistry.for(verb_name.to_sym)
-          raise Textus::UsageError.new("unknown verb: #{verb_name}") unless spec
-
-          bound = Textus::Dispatch::Binder.inputs_from_wire(spec, inputs)
-          result = store.public_send(verb_name.to_sym, **bound)
-          spec.view(@view_key).call(result, bound)
-        end
-      end
-    end
-  end
-end

data/lib/textus/surface/mcp.rb

@@ -1,8 +0,0 @@
-module Textus
-  module Surface
-    # The agent gate. Stdio JSON-RPC 2.0 server speaking MCP draft 2024-11-05.
-    # Wraps Textus::Surface::RoleScope as auto-derived tools. See ADR 0015.
-    module MCP
-    end
-  end
-end

data/lib/textus/value/command.rb

@@ -1,16 +0,0 @@
-module Textus
-  module Value
-    Command = Data.define(:verb, :params, :role) do
-      def initialize(verb:, params:, role:)
-        super
-        params.freeze
-        freeze
-      end
-
-      def [](key)    = params[key]
-      def key        = params[:key]
-      def pending_key = params[:pending_key]
-      def dry_run = params[:dry_run]
-    end
-  end
-end

data/lib/textus/value/envelope.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "dry-struct"
-
-module Textus
-  module Value
-    class Envelope < Dry::Struct
-      attribute :protocol,   Types::String
-      attribute :key,        Types::String
-      attribute :lane,       Types::String
-      attribute :owner,      Types::String.optional
-      attribute :path,       Types::String
-      attribute :format,     Types::FormatName
-      attribute :etag,       Types::String
-      attribute :uid,        Types::String.optional
-      attribute :sources,    Types::Array.of(Types::Any).optional
-      attribute :schema_ref, Types::String.optional
-      attribute :meta,       Types::Hash.default({}.freeze)
-      attribute :body,       Types::String.optional
-      attribute :content,    Types::Any.optional
-      attribute :freshness,  Types::Any.optional
-
-      def self.build(key:, mentry:, path:, meta:, body:, etag:, content: nil, freshness: nil)
-        new(
-          protocol: Textus::PROTOCOL,
-          key: key,
-          lane: mentry.lane,
-          owner: mentry.owner,
-          path: path,
-          format: mentry.format,
-          uid: extract_uid(meta),
-          sources: extract_sources(meta),
-          etag: etag,
-          schema_ref: mentry.schema,
-          meta: meta,
-          body: body,
-          content: content,
-          freshness: freshness,
-        )
-      end
-
-      def self.extract_uid(meta)
-        v = meta.is_a?(Hash) ? meta["uid"] : nil
-        v.is_a?(String) ? v : nil
-      end
-
-      def self.extract_sources(meta)
-        v = meta.is_a?(Hash) ? meta["sources"] : nil
-        return nil unless v.is_a?(Array) && !v.empty?
-
-        valid = v.select { |s| s.is_a?(String) || (s.is_a?(Hash) && s["key"].is_a?(String)) }
-        valid.empty? ? nil : valid
-      end
-
-      def with(**attrs) = self.class.new(to_h.merge(attrs))
-
-      def to_h_for_wire
-        h = {
-          "protocol" => protocol,
-          "key" => key,
-          "lane" => lane,
-          "owner" => owner,
-          "path" => path,
-          "format" => format,
-          "_meta" => meta,
-          "body" => body,
-          "etag" => etag,
-          "schema_ref" => schema_ref,
-          "uid" => uid,
-        }
-        h["sources"] = sources if sources
-        h["content"] = content unless content.nil?
-        freshness&.to_h_for_wire&.each { |k, v| h[k] = v }
-        h
-      end
-
-      def stale?
-        return false if freshness.nil?
-
-        freshness.stale == true
-      end
-
-      def fetching?
-        return false if freshness.nil?
-
-        freshness.fetching == true
-      end
-    end
-  end
-end

data/lib/textus/value/result.rb

@@ -1,46 +0,0 @@
-module Textus
-  module Value
-    # rubocop:disable Lint/ConstantDefinitionInBlock
-    Result = Data.define(:ok, :value, :error) do
-      def self.success(value) = new(ok: true, value: value, error: nil)
-
-      def self.failure(code, message, details: {})
-        new(ok: false, value: nil, error: { code: code, message: message, details: details })
-      end
-
-      def self.extract(result)
-        case result
-        when self
-          if result.success?
-            result.value
-          else
-            err = result.error
-            raise Textus::ActionError.new(err[:code] || :error, err[:message] || "action failed", details: err[:details] || {})
-          end
-        else
-          result
-        end
-      end
-
-      def success? = ok
-      def failure? = !ok
-
-      def unwrap
-        raise Result::UnwrapError.new(error[:code], error[:message], details: error[:details]) unless ok
-
-        value
-      end
-
-      class UnwrapError < StandardError
-        attr_reader :code, :details
-
-        def initialize(code, message, details: {})
-          super(message)
-          @code = code
-          @details = details
-        end
-      end
-    end
-    # rubocop:enable Lint/ConstantDefinitionInBlock
-  end
-end