textus 0.55.1 → 0.56.0

data/lib/textus/port/store.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "sqlite3"
-
-module Textus
-  module Port
-    # SQLite-backed runtime store for textus state. Owns the connection,
-    # schema setup, WAL mode, and transaction boundary for the index and queue.
-    class Store
-      attr_reader :path, :connection
-
-      def initialize(root:)
-        @root = root
-        @path = Textus::Store::Geometry.new(root).store_db_path
-        FileUtils.mkdir_p(File.dirname(@path))
-        @connection = SQLite3::Database.new(@path)
-        @connection.results_as_hash = true
-      end
-
-      def execute(sql, params = [])
-        @connection.execute(sql, params)
-      end
-
-      def query_value(sql, params = [])
-        @connection.get_first_value(sql, params)
-      end
-
-      def setup!
-        execute("PRAGMA journal_mode=WAL")
-        execute("PRAGMA foreign_keys=ON")
-        connection.execute_batch(<<~SQL)
-          CREATE TABLE IF NOT EXISTS entries (
-            key        TEXT PRIMARY KEY,
-            lane       TEXT NOT NULL,
-            format     TEXT NOT NULL,
-            etag       TEXT,
-            content    TEXT,
-            extra      TEXT,
-            indexed_at TEXT NOT NULL
-          ) STRICT;
-
-          CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(
-            key, lane, content,
-            content=entries, content_rowid=rowid
-          );
-
-          CREATE TABLE IF NOT EXISTS jobs (
-            id               TEXT PRIMARY KEY,
-            type             TEXT NOT NULL,
-            args             TEXT NOT NULL,
-            state            TEXT NOT NULL DEFAULT 'ready',
-            role             TEXT NOT NULL,
-            attempts         INTEGER NOT NULL DEFAULT 0,
-            max_attempts     INTEGER NOT NULL DEFAULT 3,
-            errors           TEXT,
-            lease            TEXT,
-            created_at       TEXT NOT NULL,
-            updated_at       TEXT NOT NULL
-          ) STRICT;
-
-          CREATE INDEX IF NOT EXISTS idx_jobs_state ON jobs(state);
-          CREATE INDEX IF NOT EXISTS idx_entries_lane ON entries(lane);
-        SQL
-        self
-      end
-
-      def transaction
-        connection.transaction
-        yield
-        connection.commit
-      rescue StandardError
-        connection.rollback if connection.transaction_active?
-        raise
-      end
-
-      def close
-        connection.close unless connection.closed?
-      end
-
-      def self.open(root)
-        store = new(root: root)
-        store.setup!
-        return store unless block_given?
-
-        yield store
-      ensure
-        store&.close
-      end
-      private :connection
-    end
-  end
-end

data/lib/textus/port/watcher_lock.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "socket"
-
-module Textus
-  module Port
-    # Flock-based watcher presence lock. Held for the watcher's lifetime.
-    # Process death releases the flock automatically.
-    class WatcherLock
-      def initialize(root)
-        @path = Textus::Store::Geometry.new(root).lock_path("watcher")
-        @file = nil
-        FileUtils.mkdir_p(File.dirname(@path))
-      end
-
-      def self.running?(root)
-        path = Textus::Store::Geometry.new(root).lock_path("watcher")
-        return false unless File.exist?(path)
-
-        File.open(path, "r+") do |file|
-          got = file.flock(File::LOCK_EX | File::LOCK_NB)
-          file.flock(File::LOCK_UN) if got
-          return !got
-        end
-      rescue Errno::ENOENT
-        false
-      end
-
-      def acquire
-        @file = File.open(@path, File::RDWR | File::CREAT, 0o644)
-        raise "watcher already running" unless @file.flock(File::LOCK_EX | File::LOCK_NB)
-
-        @file.write("pid=#{Process.pid} host=#{Socket.gethostname}\n")
-        @file.flush
-        self
-      end
-
-      def release
-        return unless @file
-
-        @file.flock(File::LOCK_UN)
-        @file.close
-        FileUtils.rm_f(@path)
-        @file = nil
-      end
-    end
-  end
-end

data/lib/textus/produce/engine.rb

@@ -1,50 +0,0 @@
-module Textus
-  module Produce
-    class Engine
-      def self.converge(container:, call:, keys:)
-        new(container:, call:).run(keys)
-      end
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-      end
-
-      def run(keys)
-        results = { completed: [], failed: [] }
-        Array(keys).each { |key| produce_one(key, results) }
-        results
-      end
-
-      alias call run
-
-      private
-
-      def produce_one(key, results)
-        workflow = @container.workflows.for(key)
-        if workflow
-          Workflow::Runner.new(workflow, container: @container, call: @call).run(key)
-        else
-          publish_only(key)
-        end
-        results[:completed] << key
-      rescue StandardError => e
-        results[:failed] << { key: key, error: e.message }
-      end
-
-      def publish_only(key)
-        entry = @container.manifest.resolver.resolve(key).entry
-        return unless entry.publish_tree || !Array(entry.publish_to).empty?
-
-        reader     = Textus::Store::Envelope::Reader.from(container: @container)
-        entry_path = @container.manifest.resolver.resolve(key).path
-        return unless entry.publish_tree || File.exist?(entry_path)
-
-        pctx = Textus::Manifest::Entry::Base::PublishContext.new(
-          container: @container, call: @call, reader: reader.method(:read),
-        )
-        entry.publish_via(pctx)
-      end
-    end
-  end
-end

data/lib/textus/produce/render.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-
-module Textus
-  module Produce
-    class Render
-      def initialize(template_loader:)
-        @template_loader = template_loader
-      end
-
-      def bytes_for(target:, data:, boot:)
-        raise ArgumentError.new("Produce::Render called for a verbatim target #{target.to.inspect}") unless target.renders?
-
-        ctx = target.inject_boot ? data.merge("boot" => boot) : data
-        ERB.new(@template_loader.call(target.template), trim_mode: "-").result_with_hash(ctx)
-      end
-    end
-  end
-end

data/lib/textus/schema/tools.rb

@@ -1,115 +0,0 @@
-require "yaml"
-require "fileutils"
-
-module Textus
-  class Schema
-    module Tools
-      # textus schema init NAME --from=KEY  → infer YAML schema from an entry's frontmatter
-      def self.init(store, name:, from:)
-        env = pure_get(store, Textus::Value::Role::DEFAULT, from)
-        meta = env.meta
-        schema = {
-          "name" => name,
-          "required" => meta.keys,
-          "optional" => [],
-          "fields" => meta.each_with_object({}) { |(k, v), h| h[k] = { "type" => infer_type(v) } },
-        }
-        geom = Textus::Store::Geometry.new(store.root)
-        FileUtils.mkdir_p(geom.schemas_dir)
-        target = geom.schema_path(name)
-        File.write(target, YAML.dump(schema))
-        { "protocol" => PROTOCOL, "schema_name" => name, "path" => target }
-      end
-
-      # textus schema diff NAME  → list keys whose frontmatter violates the schema
-      def self.diff(store, name:)
-        schema = load_schema(store, name)
-        drift = []
-        store.manifest.resolver.enumerate.each do |row|
-          env = pure_get(store, Textus::Value::Role::DEFAULT, row[:key])
-          begin
-            schema.validate!(env.meta)
-          rescue SchemaViolation => e
-            drift << { "key" => row[:key], "details" => e.details }
-          end
-        end
-        { "protocol" => PROTOCOL, "schema_name" => name, "drift" => drift }
-      end
-
-      # textus schema migrate NAME --rename=OLD:NEW → rewrites frontmatter across affected entries
-      # If --rename is omitted, falls back to schema.evolution.migrate_from.
-      def self.migrate(store, name:, rename: nil)
-        renames =
-          if rename
-            old_field, new_field = rename.split(":", 2)
-            raise UsageError.new("--rename=OLD:NEW") unless old_field && new_field && !new_field.empty?
-
-            { old_field => new_field }
-          else
-            load_schema(store, name).evolution["migrate_from"] || {}
-          end
-        raise UsageError.new("schema migrate needs --rename=OLD:NEW or schema.evolution.migrate_from") if renames.empty?
-
-        authority = accept_role_for(store)
-        ops = store.as(authority)
-        touched = []
-        store.manifest.resolver.enumerate.each do |row|
-          env = pure_get(store, authority, row[:key])
-          meta = env.meta.dup
-          changed = false
-          renames.each do |old, new|
-            if meta.key?(old)
-              meta[new] = meta.delete(old)
-              changed = true
-            end
-          end
-          next unless changed
-
-          ops.put(row[:key], meta: meta, body: env.body)
-          touched << row[:key]
-        end
-        { "protocol" => PROTOCOL, "migrated" => touched, "renames" => renames }
-      end
-
-      def self.infer_type(value)
-        case value
-        when String  then "string"
-        when Numeric then "number"
-        when true, false then "boolean"
-        when Array   then "array"
-        when Hash    then "object"
-        else "string"
-        end
-      end
-
-      # Orchestrator-free read: schema tooling must never trigger a fetch
-      # while inspecting/migrating entries (ADR 0062).
-      def self.pure_get(store, role, key)
-        scope = store.as(role)
-        Value::Result.unwrap(
-          Textus::Action::Get.call(
-            container: scope.container,
-            call: Textus::Value::Call.build(role: role),
-            key: key,
-          ),
-        )
-      end
-
-      def self.load_schema(store, name)
-        store.schemas.fetch(name)
-      rescue IoError
-        raise UsageError.new("schema not found: #{name}")
-      end
-
-      def self.accept_role_for(store)
-        authority = store.manifest.policy.roles_with_capability("author").first
-        return authority if authority
-
-        raise UsageError.new(
-          "schema migrate requires a role holding the 'author' capability; " \
-          "none declared (add e.g. `- { name: owner, can: [author] }` to roles:)",
-        )
-      end
-    end
-  end
-end

data/lib/textus/schema.rb

@@ -1,100 +0,0 @@
-require "yaml"
-
-module Textus
-  class Schema
-    attr_reader :name, :required, :optional, :fields, :raw
-
-    def self.load(path)
-      raw = YAML.safe_load_file(path, permitted_classes: [Symbol, Date, Time], aliases: false)
-      new(raw)
-    end
-
-    def initialize(raw)
-      @raw = raw || {}
-      @name = @raw["name"]
-      @required = Array(@raw["required"])
-      @optional = Array(@raw["optional"])
-      @fields = @raw["fields"] || {}
-    end
-
-    def to_h
-      @raw
-    end
-
-    def maintained_by(field)
-      meta = @fields[field] or return nil
-      meta["maintained_by"]
-    end
-
-    # Returns the list of field names whose spec is a Hash but lacks the
-    # 'maintained_by' key. Used by Doctor::Check::UnownedSchemaFields.
-    def unowned_fields
-      @fields.each_with_object([]) do |(name, spec), acc|
-        next unless spec.is_a?(Hash)
-
-        acc << name if spec["maintained_by"].nil?
-      end
-    end
-
-    def evolution
-      raw = @raw["evolution"] || {}
-      raw.each_with_object({}) do |(k, v), h|
-        h[k] = v.is_a?(Date) || v.is_a?(Time) ? v.to_s : v
-      end
-    end
-
-    # Returns nil on success; raises SchemaViolation on hard failure.
-    # Unknown fields produce warnings, returned as a String[] alongside.
-    def validate!(frontmatter)
-      missing = @required - frontmatter.keys
-      raise SchemaViolation.new("missing" => missing) unless missing.empty?
-
-      known = (@required + @optional).uniq
-      frontmatter.each do |k, v|
-        next unless @fields.key?(k)
-
-        check_type!(k, v, @fields[k])
-      end
-
-      warnings = frontmatter.keys - known
-      warnings.map { |w| "unknown field: #{w}" }
-    end
-
-    private
-
-    def check_type!(field, value, spec) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      type = spec["type"]
-      case type
-      when "string"
-        bad!(field, "expected string") unless value.is_a?(String)
-        if (max = spec["max"]) && value.bytesize > max
-          bad!(field, "exceeds max #{max}")
-        end
-      when "number"
-        bad!(field, "expected number") unless value.is_a?(Numeric)
-      when "boolean"
-        bad!(field, "expected boolean") unless [true, false].include?(value)
-      when "enum"
-        values = Array(spec["values"])
-        bad!(field, "not in enum #{values.inspect}") unless values.include?(value)
-      when "array"
-        bad!(field, "expected array") unless value.is_a?(Array)
-        if (items = spec["items"])
-          value.each_with_index { |v, i| check_type!("#{field}[#{i}]", v, items) }
-        end
-      when "object"
-        bad!(field, "expected object") unless value.is_a?(Hash)
-        if (sub = spec["fields"])
-          sub.each { |fk, fspec| check_type!("#{field}.#{fk}", value[fk], fspec) if value.key?(fk) }
-        end
-      when nil
-        # untyped — no check
-        # unknown type spec — vendor extension; ignore
-      end
-    end
-
-    def bad!(field, reason)
-      raise SchemaViolation.new("field" => field, "reason" => reason)
-    end
-  end
-end

data/lib/textus/schemas.rb

@@ -1,54 +0,0 @@
-module Textus
-  # Eager-loading schema cache. Loads every *.yaml under +dir+ at construction.
-  # A missing directory is treated as "no schemas" (does not raise) to mirror
-  # the lazy behavior previously embedded in Store#schema_for.
-  class Schemas
-    def initialize(dir)
-      @dir = dir
-      @schemas = {}
-      load_all
-    end
-
-    def fetch(name)
-      @schemas[name] || raise(IoError.new("schema not found: #{File.join(@dir, "#{name}.yaml")}"))
-    end
-
-    # Only nil short-circuits. A missing-but-named schema still raises IoError.
-    def fetch_or_nil(name)
-      return nil if name.nil?
-
-      fetch(name)
-    end
-
-    def all
-      @schemas.values
-    end
-
-    # Name-keyed view: { canonical_name => Schema }. The key is the schema's
-    # file stem, which is authoritative even when a schema file carries no
-    # top-level `name:` (Schema#name reads the body and may be nil). Symmetric
-    # with #all (values); use this when you need the names too.
-    def by_name
-      @schemas.dup
-    end
-
-    private
-
-    def load_all
-      return unless File.directory?(@dir)
-
-      Dir.glob(File.join(@dir, "*.yaml")).each do |path|
-        name = File.basename(path, ".yaml")
-        begin
-          @schemas[name] = Schema.load(path)
-        rescue StandardError
-          # Tolerate broken schema files at construction time so the rest of
-          # the store remains loadable. Surfacing the failure is the job of
-          # Doctor::Check::SchemaParseError. Lookups via #fetch still raise
-          # IoError for the missing-but-named schema.
-          next
-        end
-      end
-    end
-  end
-end

data/lib/textus/store/compositor.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  class Store
-    class Compositor
-      def initialize(container)
-        @container = container
-      end
-
-      def write(key, mentry:, payload:, call:, if_etag: nil)
-        Textus::Store::Envelope::Writer.from(container: @container, call: call)
-                                       .put(key, mentry: mentry, payload: payload, if_etag: if_etag)
-      end
-
-      def read(key)
-        Textus::Store::Envelope::Reader.from(container: @container).read(key)
-      end
-
-      def delete(key, call:, mentry: nil, if_etag: nil)
-        Textus::Store::Envelope::Writer.from(container: @container, call: call)
-                                       .delete(key, mentry: mentry, if_etag: if_etag)
-      end
-
-      def move(from_key:, to_key:, new_mentry:, call:, if_etag: nil)
-        Textus::Store::Envelope::Writer.from(container: @container, call: call)
-                                       .move(from_key: from_key, to_key: to_key, new_mentry: new_mentry, if_etag: if_etag)
-      end
-
-      def exists?(key)
-        Textus::Store::Envelope::Reader.from(container: @container).exists?(key)
-      end
-    end
-  end
-end

data/lib/textus/store/container.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  class Store
-    class Container
-      Infrastructure = Data.define(:file_store, :schemas, :audit_log, :job_store, :geometry)
-      Coordination   = Data.define(:manifest, :workflows, :gate, :compositor)
-
-      def self.attribute_names
-        @attribute_names ||= [:root] + Infrastructure.members + Coordination.members
-      end
-
-      def initialize(infra, coord)
-        @infra = infra
-        @coord = coord
-      end
-
-      attr_reader :infra, :coord
-
-      def root
-        @infra.geometry.root
-      end
-
-      Infrastructure.members.each do |name|
-        define_method(name) { @infra.public_send(name) }
-      end
-
-      Coordination.members.each do |name|
-        define_method(name) { @coord.public_send(name) }
-      end
-
-      def wire_gate!(gate, compositor)
-        @coord = Coordination.new(
-          manifest: @coord.manifest,
-          workflows: @coord.workflows,
-          gate:,
-          compositor:,
-        )
-        self
-      end
-    end
-  end
-end

data/lib/textus/store/cursor.rb

@@ -1,26 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    # Per-role cursor cache under <root>/.state/cursors/<role>. A convenience so
-    # `textus pulse` (no --since) means "since I last looked". Gitignored;
-    # losing it just re-emits recent deltas, never corrupts the store. ADR 0036/0038.
-    class Cursor
-      def initialize(root:, role:)
-        @path = Store::Geometry.new(root).cursor_path(role)
-      end
-
-      def read
-        Integer(File.read(@path).strip)
-      rescue Errno::ENOENT, ArgumentError
-        0
-      end
-
-      def write(seq)
-        FileUtils.mkdir_p(File.dirname(@path))
-        File.write(@path, seq.to_s)
-        seq
-      end
-    end
-  end
-end

data/lib/textus/store/envelope/reader.rb

@@ -1,43 +0,0 @@
-module Textus
-  class Store
-    module Envelope
-      # Read-only counterpart to EnvelopeWriter. Resolves a key, reads the
-      # bytes, parses them via the format strategy, and hands back an
-      # Envelope. Used by Mv (pre-move inspection) and by EnvelopeWriter
-      # (existing-meta lookup for the uid/sources preservation step in #put).
-      #
-      # No audit, no events, no permission checks — those live one layer up.
-      class Reader
-        def self.from(container:)
-          new(file_store: container.file_store, manifest: container.manifest,
-              geometry: container.geometry)
-        end
-
-        def initialize(file_store:, manifest:, geometry:)
-          @file_store = file_store
-          @manifest   = manifest
-          @geometry   = geometry
-        end
-
-        def read(key)
-          res = @manifest.resolver.resolve(key)
-          path = res.path
-          return nil unless @file_store.exists?(path)
-
-          mentry = res.entry
-          raw = @file_store.read(path)
-          parsed = Format.for(mentry.format).parse(raw, path: path)
-          Textus::Value::Envelope.build(
-            key: key, mentry: mentry, path: path,
-            meta: parsed["_meta"], body: parsed["body"],
-            etag: Value::Etag.for_bytes(raw), content: parsed["content"]
-          )
-        end
-
-        def exists?(key)
-          @file_store.exists?(@manifest.resolver.resolve(key).path)
-        end
-      end
-    end
-  end
-end