textus 0.55.2 → 0.56.0

data/lib/textus/port/sentinel_store.rb

@@ -1,83 +0,0 @@
-require "json"
-require "digest"
-require "fileutils"
-
-module Textus
-  module Port
-    # Persistence adapter for sentinel files. Owns the on-disk JSON shape, the
-    # path layout (<store_root>/.run/sentinels/<target-rel-to-repo>.textus-managed.json
-    # — runtime, git-ignored, ADR 0070), and all File/FileUtils I/O.
-    # Core::Sentinel is a pure value object that depends on this port for
-    # reads and writes.
-    class SentinelStore
-      SUFFIX = ".textus-managed.json".freeze
-
-      def write!(target:, source:, store_root:)
-        path = sentinel_path(target, store_root)
-        FileUtils.mkdir_p(File.dirname(path))
-        repo_root = File.dirname(store_root)
-        File.write(path, JSON.generate(
-                           "source" => rel_or_abs(source, repo_root),
-                           "target" => rel_or_abs(target, repo_root),
-                           "sha256" => Digest::SHA256.hexdigest(File.binread(target)),
-                           "mode" => "copy",
-                         ))
-      end
-
-      def load(path, repo_root)
-        raw = JSON.parse(File.read(path))
-        Textus::Port::Sentinel.new(
-          target: absolutize(raw["target"], repo_root),
-          source: absolutize(raw["source"], repo_root),
-          sha256: raw["sha256"],
-          mode: raw["mode"],
-        )
-      rescue JSON::ParserError, Errno::ENOENT
-        nil
-      end
-
-      def sentinel_path(target, store_root)
-        repo_root = File.dirname(store_root)
-        rel = relative_to(target, repo_root) || File.basename(target)
-        File.join(Textus::Store::Layout.new(store_root).sentinels_root, rel + SUFFIX)
-      end
-
-      # Absolute target paths of every sentinel recorded under `target_dir`.
-      def targets_under(target_dir, store_root)
-        repo_root = File.dirname(store_root)
-        rel = relative_to(target_dir, repo_root) or return []
-        root = Textus::Store::Layout.new(store_root).sentinels_root
-        sdir = File.join(root, rel)
-        return [] unless File.directory?(sdir)
-
-        prefix = root + "/"
-        Dir.glob(File.join(sdir, "**", "*#{SUFFIX}")).map do |spath|
-          # strip the sentinel-store prefix and the .textus-managed.json suffix to recover the repo-relative target path
-          trel = spath.delete_prefix(prefix).delete_suffix(SUFFIX)
-          File.join(repo_root, trel)
-        end
-      end
-
-      private
-
-      def rel_or_abs(path, repo_root)
-        relative_to(path, repo_root) || File.expand_path(path)
-      end
-
-      def relative_to(path, repo_root)
-        path = File.expand_path(path)
-        base = File.expand_path(repo_root)
-        return nil unless path.start_with?(base + File::SEPARATOR)
-
-        path[(base.length + 1)..]
-      end
-
-      def absolutize(path, repo_root)
-        return path if path.nil?
-        return path if File.absolute_path?(path)
-
-        File.expand_path(path, repo_root)
-      end
-    end
-  end
-end

data/lib/textus/port/storage/file_stat.rb

@@ -1,19 +0,0 @@
-module Textus
-  module Port
-    module Storage
-      # Read-only filesystem query port. The narrow interface that pure
-      # domain logic (staleness checks, sentinel value) depends on, so the
-      # domain never touches File/Dir directly. FileStore owns the write side.
-      class FileStat
-        def exists?(path)    = File.exist?(path)
-        def directory?(path) = File.directory?(path)
-        def read(path)       = File.binread(path)
-        def mtime(path)      = File.mtime(path)
-
-        # Ruby 3.3+ guarantees Dir.glob returns a sorted Array; no explicit sort
-        # needed, but callers can rely on ordered results for stable behaviour.
-        def glob(pattern)    = Dir.glob(pattern)
-      end
-    end
-  end
-end

data/lib/textus/port/storage/file_store.rb

@@ -1,49 +0,0 @@
-require "fileutils"
-
-module Textus
-  module Port
-    module Storage
-      # Pure filesystem I/O port. Wraps File/FileUtils/Etag with no knowledge
-      # of envelopes, entries, schemas, or audit.
-      class FileStore
-        include Interface
-
-        def read(path) = File.binread(path)
-
-        def write(path, bytes)
-          FileUtils.mkdir_p(File.dirname(path))
-          File.binwrite(path, bytes)
-        end
-
-        # Raises Errno::ENOENT if absent — mirrors File.delete and matches the
-        # semantics used by Store::Writer (which guards with File.exist? first).
-        def delete(path) = File.delete(path)
-
-        def exists?(path) = File.exist?(path)
-
-        def etag(path) = Value::Etag.for_file(path)
-
-        # Convenience filesystem ops so callers can go through the port
-        # instead of calling FileUtils/Dir directly. Keeps filesystem
-        # semantics in one place for easier testing and replacement.
-        def mkdir_p(path)
-          FileUtils.mkdir_p(path)
-        end
-
-        def mv(from_path, to_path)
-          FileUtils.mkdir_p(File.dirname(to_path))
-          FileUtils.mv(from_path, to_path)
-        end
-
-        def rmdir(path)
-          Dir.rmdir(path)
-        end
-
-        def dir_empty?(dir)
-          # Dir.empty? exists on modern Rubies; wrap for clarity
-          Dir.empty?(dir)
-        end
-      end
-    end
-  end
-end

data/lib/textus/port/storage/interface.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Port
-    module Storage
-      module Interface
-        def read(path) = raise NotImplementedError
-        def write(path, bytes) = raise NotImplementedError
-        def delete(path) = raise NotImplementedError
-        def exists?(path) = raise NotImplementedError
-        def etag(path) = raise NotImplementedError
-        def mkdir_p(path) = raise NotImplementedError
-        def mv(from_path, to_path) = raise NotImplementedError
-        def rmdir(path) = raise NotImplementedError
-        def dir_empty?(dir) = raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/textus/port/store.rb

@@ -1,149 +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:)
-        @path = Textus::Store::Layout.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);
-
-          CREATE TABLE IF NOT EXISTS audit_events (
-            seq          INTEGER PRIMARY KEY,
-            ts           TEXT NOT NULL,
-            role         TEXT NOT NULL,
-            verb         TEXT NOT NULL,
-            key          TEXT NOT NULL,
-            etag_before  TEXT,
-            etag_after   TEXT
-          ) STRICT;
-
-          CREATE INDEX IF NOT EXISTS idx_audit_events_seq ON audit_events(seq);
-        SQL
-        # Idempotent migration: add schema_ref column if missing (existing stores).
-        execute("ALTER TABLE entries ADD COLUMN schema_ref TEXT") rescue nil # rubocop:disable Style/RescueModifier
-        self
-      end
-
-      def search_entries(q: nil, schema: nil, lane: nil, prefix: nil) # rubocop:disable Naming/MethodParameterName
-        return nil if q.nil? && schema.nil?
-
-        if q
-          fts_search(q: q, schema: schema, lane: lane, prefix: prefix)
-        else
-          schema_search(schema: schema, lane: lane, prefix: prefix)
-        end
-      end
-
-      def insert_audit_event(seq:, ts:, role:, verb:, key:, etag_before:, etag_after:) # rubocop:disable Naming/MethodParameterName
-        execute(
-          "INSERT OR IGNORE INTO audit_events (seq, ts, role, verb, key, etag_before, etag_after) VALUES (?, ?, ?, ?, ?, ?, ?)",
-          [seq, ts, role, verb, key, etag_before, etag_after],
-        )
-      end
-
-      def audit_events_since(seq:)
-        execute(
-          "SELECT seq, ts, role, verb, key, etag_before, etag_after FROM audit_events WHERE seq > ? ORDER BY seq",
-          [seq],
-        )
-      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
-
-      def fts_search(q:, schema:, lane:, prefix:) # rubocop:disable Naming/MethodParameterName
-        sql    = "SELECT e.key, e.lane, e.schema_ref FROM entries e JOIN entries_fts fts ON e.rowid = fts.rowid WHERE entries_fts MATCH ?"
-        params = [q]
-        sql += " AND e.lane = ?"                  and params << lane                       if lane
-        sql += " AND e.schema_ref = ?"            and params << schema                     if schema
-        sql += " AND (e.key = ? OR e.key LIKE ?)" and params.push(prefix, "#{prefix}.%")   if prefix
-        execute(sql, params)
-      end
-      private :fts_search
-
-      def schema_search(schema:, lane:, prefix:)
-        sql    = "SELECT key, lane, schema_ref FROM entries WHERE schema_ref = ?"
-        params = [schema]
-        sql += " AND lane = ?"                    and params << lane                       if lane
-        sql += " AND (key = ? OR key LIKE ?)"     and params.push(prefix, "#{prefix}.%")   if prefix
-        execute(sql, params)
-      end
-      private :schema_search
-    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::Layout.new(root).lock_path("watcher")
-        @file = nil
-        FileUtils.mkdir_p(File.dirname(@path))
-      end
-
-      def self.running?(root)
-        path = Textus::Store::Layout.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,40 +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)
-        Textus::Produce::Publisher.call(container: @container, call: @call, key: key)
-      end
-    end
-  end
-end

data/lib/textus/produce/publisher.rb

@@ -1,21 +0,0 @@
-module Textus
-  module Produce
-    module Publisher
-      def self.call(container:, call:, key:)
-        entry = container.manifest.resolver.resolve(key).entry
-        return unless entry.publish_tree || !Array(entry.publish_to).empty?
-
-        entry_path = container.manifest.resolver.resolve(key).path
-        return unless entry.publish_tree || container.file_store.exists?(entry_path)
-
-        reader = Textus::Store::Entry::Reader.from(container: container)
-        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/registry.rb

@@ -1,42 +0,0 @@
-module Textus
-  class Schema
-    class Registry
-      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
-
-      def fetch_or_nil(name)
-        return nil if name.nil?
-
-        fetch(name)
-      end
-
-      def all
-        @schemas.values
-      end
-
-      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")
-          @schemas[name] = Schema.load(path)
-        rescue StandardError => e
-          warn "textus: failed to load schema '#{name}' at #{path}: #{e.message}"
-        end
-      end
-    end
-  end
-end

data/lib/textus/schema/tools.rb

@@ -1,108 +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::Layout.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.with_role(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)
-        store.with_role(role).get(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