textus 0.55.1 → 0.56.0

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

@@ -1,50 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    module Jobs
-      class Retention
-        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"]
-          root = @container.root.to_s
-          rel  = src.delete_prefix("#{root}/")
-          dest = File.join(root, "archive", rel)
-          FileUtils.mkdir_p(File.dirname(dest))
-          FileUtils.cp(src, dest)
-        end
-
-        def delete(key)
-          Textus::Action::KeyDelete.call(container: @container, call: @call, key: key)
-        end
-      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 = Textus::Core::Retention::Sweep.new(
-            manifest: container.manifest,
-            file_stat: Textus::Port::Storage::FileStat.new,
-            clock: Textus::Port::Clock.new,
-          ).call(prefix: prefix, lane: lane)
-          Textus::Store::Jobs::Retention.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/session.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "dry-struct"
-
-module Textus
-  # The agent session: per-connection (MCP), per-process (CLI), or per-loop
-  # (Ruby) orientation state — the audit cursor plus the contract etag and
-  # propose_lane captured at boot. Immutable Dry::Struct::Value; advance_cursor
-  # and with return new instances. ADR 0036; contract_etag widened in ADR 0074.
-  class Store
-    class Session < Dry::Struct
-      attribute :role,          Value::Types::RoleName
-      attribute :cursor,        Value::Types::Cursor
-      attribute :propose_lane,  Value::Types::String.optional
-      attribute :contract_etag, Value::Types::String
-
-      def with(**attrs) = self.class.new(to_h.merge(attrs))
-
-      def advance_cursor(new_cursor) = with(cursor: new_cursor)
-
-      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
-
-      # First 8 hex chars after the "sha256:" prefix — a stable short id for
-      # the drift diagnostic.
-      def short_etag(etag) = etag.to_s.delete_prefix("sha256:")[0, 8]
-    end
-  end
-end

data/lib/textus/store.rb

@@ -1,99 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    attr_reader :container
-
-    # Readers are derived from the Container's schema, so the field set lives
-    # in exactly one place (Container). A new capability added there is
-    # automatically exposed on the Store.
-    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)
-      @container = build_container(File.expand_path(root))
-    end
-
-    # Build an agent Session oriented at the current cursor/manifest — the
-    # Ruby equivalent of an MCP `initialize`. ADR 0036.
-    def session(role:)
-      Textus::Store::Session.new(
-        role: role.to_s,
-        cursor: audit_log.latest_seq,
-        propose_lane: manifest.policy.propose_lane_for(role),
-        contract_etag: Textus::Value::Etag.for_contract(root),
-      )
-    end
-
-    def gate
-      @container.gate
-    end
-
-    def as(role, dry_run: false, correlation_id: nil)
-      Textus::Surface::RoleScope.new(container: container, role: role, dry_run: dry_run, correlation_id: correlation_id)
-    end
-
-    private
-
-    def build_container(root)
-      manifest = Manifest.load(root)
-      job_store = Port::Store.new(root: root).setup!
-      geometry = Store::Geometry.new(root)
-      infra = Container::Infrastructure.new(
-        file_store: Port::Storage::FileStore.new,
-        schemas: Schemas.new(geometry.schemas_dir),
-        audit_log: Port::AuditLog.new(
-          root,
-          max_size: manifest.data.audit_config[:max_size],
-          keep: manifest.data.audit_config[:keep],
-        ),
-        job_store:,
-        geometry:,
-      )
-
-      coord = Container::Coordination.new(
-        manifest:,
-        workflows: Workflow::Loader.load_all(root),
-        gate: nil,
-        compositor: nil,
-      )
-
-      container = Container.new(infra, coord)
-      compositor = Store::Compositor.new(container)
-      gate = Textus::Gate.new(container)
-      container.wire_gate!(gate, compositor)
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Textus
-  module Surface
-    class CLI
-      class Verb
-        class Doctor < Verb
-          command_name "doctor"
-          option :checks, "--check=NAME"
-
-          def call(store)
-            spec = Textus::Action::Doctor.contract
-            inputs = { checks: checks&.split(",")&.map(&:strip) }
-            res = store.gate.dispatch(spec: spec, inputs: inputs, role: resolved_role(store))
-            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.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/surface/projector.rb

@@ -1,27 +0,0 @@
-module Textus
-  module Surface
-    class Projector
-      def initialize(view_key: :default, binder_method: :inputs_from_wire)
-        @view_key = view_key
-        @binder_method = binder_method
-      end
-
-      def verbs(action_verbs = Textus::Action::VERBS)
-        action_verbs.select do |_verb, klass|
-          klass.respond_to?(:contract?) && klass.contract?
-        end
-      end
-
-      def names(action_verbs = Textus::Action::VERBS)
-        verbs(action_verbs).keys.map(&:to_s)
-      end
-
-      def dispatch(verb_name, inputs:, store:, role:, session: nil)
-        klass = Textus::Action::VERBS.fetch(verb_name.to_sym)
-        spec = klass.contract
-        bound = Textus::Gate::Binder.public_send(@binder_method, spec, inputs)
-        store.gate.dispatch(spec:, inputs: bound, role:, session:, surface: @view_key)
-      end
-    end
-  end
-end

data/lib/textus/surface/role_scope.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Surface
-    # Role-scoped identity carrier. Holds the acting identity (role,
-    # correlation_id, dry_run) bound to a container. All verb methods
-    # (put, get, accept, ...) are injected by textus.rb's define_method
-    # loop, which dispatches directly through Gate.
-    class RoleScope
-      attr_reader :container, :role, :correlation_id
-
-      def initialize(container:, role:, dry_run: false, correlation_id: nil)
-        @container      = container
-        @role           = role.to_s
-        @dry_run        = dry_run
-        @correlation_id = correlation_id || SecureRandom.uuid
-      end
-
-      def dry_run? = !!@dry_run
-
-      def with_role(role)
-        self.class.new(container: @container, role:, dry_run: @dry_run, correlation_id: @correlation_id)
-      end
-
-      def with_correlation_id(cid)
-        self.class.new(container: @container, role: @role, dry_run: @dry_run, correlation_id: cid)
-      end
-
-      def with_dry_run
-        self.class.new(container: @container, role: @role, dry_run: true, correlation_id: @correlation_id)
-      end
-    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,89 +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::String).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
-
-      # rubocop:disable Metrics/ParameterLists
-      def self.build(key:, mentry:, path:, meta:, body:, etag:, content: nil, freshness: nil)
-        # rubocop:enable Metrics/ParameterLists
-        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
-        v.is_a?(Array) && !v.empty? ? v : nil
-      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,26 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Value
-    # Unwraps Dry::Monads results at the Gate seam.
-    # Every action returns Success(value) or Failure(code:, message:, details:).
-    # This module converts Failure into an ActionError for surfaces (CLI, MCP)
-    # that expect exceptions.
-    module Result
-      def self.unwrap(result)
-        case result
-        when Dry::Monads::Result::Success then result.value!
-        when Dry::Monads::Result::Failure
-          failure = result.failure
-          raise ActionError.new(
-            failure[:code] || :internal,
-            failure[:message] || "action failed",
-            details: failure[:details] || {},
-          )
-        else
-          result
-        end
-      end
-    end
-  end
-end

data/lib/textus/workflow/collector.rb

@@ -1,27 +0,0 @@
-module Textus
-  module Workflow
-    class Collector
-      @current = nil
-
-      class << self
-        attr_reader :current
-      end
-
-      def self.with(collector)
-        prev      = @current
-        @current  = collector
-        yield
-      ensure
-        @current = prev
-      end
-
-      def initialize(registry)
-        @registry = registry
-      end
-
-      def register(defn)
-        @registry.register(defn)
-      end
-    end
-  end
-end

data/lib/textus/workflow/context.rb

@@ -1,5 +0,0 @@
-module Textus
-  module Workflow
-    Context = Data.define(:key, :entry, :config, :lane, :container, :call)
-  end
-end

data/lib/textus/workflow/loader.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Workflow
-    class Loader
-      def self.load_all(root)
-        geometry = Textus::Store::Geometry.new(root)
-        registry = Registry.new
-        return registry unless File.directory?(geometry.workflow_dir)
-
-        collector = Collector.new(registry)
-        Collector.with(collector) do
-          Dir.glob(File.join(geometry.workflow_dir, "**", "*.rb")).each { |path| load path }
-        end
-        registry
-      end
-    end
-  end
-end

data/lib/textus/workflow/pattern.rb

@@ -1,18 +0,0 @@
-module Textus
-  module Workflow
-    module Pattern
-      def self.match?(pattern, key)
-        if pattern.end_with?(".**")
-          prefix = pattern.delete_suffix(".**")
-          key.start_with?("#{prefix}.")
-        elsif pattern.end_with?(".*")
-          prefix = pattern.delete_suffix(".*")
-          suffix = key.delete_prefix("#{prefix}.")
-          key != suffix && !suffix.include?(".")
-        else
-          key == pattern
-        end
-      end
-    end
-  end
-end