textus 0.54.2 → 0.55.1

data/lib/textus/{ports → port}/audit_log.rb

@@ -3,7 +3,7 @@ require "json"
 require "time"
 
 module Textus
-  module Ports
+  module Port
     # Append-only audit log adapter: writes and rotates the on-disk audit JSONL
     # under the store root. An instantiable class — it holds collaborators (the
     # root path + size/keep config), so each store binds its own instance. It
@@ -16,7 +16,7 @@ module Textus
 
       def initialize(root, max_size: DEFAULT_MAX_SIZE, keep: DEFAULT_KEEP)
         @root     = root
-        @path     = Textus::Layout.audit_log(root)
+        @path     = Textus::Store::Geometry.new(root).audit_log_path
         @max_size = max_size
         @keep     = keep
       end
@@ -72,6 +72,28 @@ module Textus
         end
       end
 
+      # Scan log files with optional filters. Returns parsed row hashes.
+      # Lane and timestamp filters are left to the caller (they need manifest
+      # resolution and Time parsing the port shouldn't know about).
+      def scan(seq_since: nil, key: nil, role: nil, verb: nil,
+               correlation_id: nil, limit: nil)
+        files = all_log_files
+        return [] if files.empty?
+
+        rows = []
+        files.each do |file|
+          File.foreach(file) do |line|
+            parsed = parse_row(line.chomp)
+            next unless parsed && matches?(parsed, seq_since:, key:, role:, verb:, correlation_id:)
+
+            rows << parsed
+            break if limit && rows.length >= limit
+          end
+          break if limit && rows.length >= limit
+        end
+        rows
+      end
+
       # Returns an array of integrity-violation descriptors for the on-disk log.
       # Each entry is { "lineno" => Integer, "reason" => String, "detail" => String }.
       # Empty array means the log is well-formed (or doesn't exist yet).
@@ -115,11 +137,11 @@ module Textus
       end
 
       def rotated(n)
-        File.join(Textus::Layout.audit_dir(@root), "audit.log.#{n}")
+        File.join(Textus::Store::Geometry.new(@root).audit_dir_path, "audit.log.#{n}")
       end
 
       def rotated_meta(n)
-        File.join(Textus::Layout.audit_dir(@root), "audit.log.#{n}.meta.json")
+        File.join(Textus::Store::Geometry.new(@root).audit_dir_path, "audit.log.#{n}.meta.json")
       end
 
       # Caller holds the flock. Returns the highest seq across the active log,
@@ -215,6 +237,24 @@ module Textus
         nil
       end
 
+      def matches?(row, seq_since: nil, key: nil, role: nil, verb: nil, correlation_id: nil)
+        return false if seq_since && row["seq"] <= seq_since
+        return false if key && row["key"] != key
+        return false if role && row["role"] != role
+        return false if verb && row["verb"] != verb
+        return false if correlation_id && row.dig("extras", "correlation_id") != correlation_id
+
+        true
+      end
+
+      def all_log_files
+        rotated = Dir.glob(File.join(Textus::Store::Geometry.new(@root).audit_dir_path, "audit.log.*"))
+                     .reject { |path| path.end_with?(".meta.json") }
+                     .sort_by { |path| -path.scan(/\d+$/).first.to_i }
+        active_log = File.exist?(@path) ? [@path] : []
+        rotated + active_log
+      end
+
       def check_line(stripped, lineno)
         return nil if stripped.empty?
 

data/lib/textus/{ports → port}/build_lock.rb

@@ -3,7 +3,7 @@ require "socket"
 require "time"
 
 module Textus
-  module Ports
+  module Port
     # Cross-process build lock: a pid/host-stamped lockfile under the store root
     # that serializes converge's produce/sweep. An instantiable class — it holds
     # the root and lock state; `self.with(root:)` is a convenience that constructs
@@ -18,7 +18,7 @@ module Textus
       end
 
       def initialize(root:)
-        @path = Textus::Layout.build_lock(root)
+        @path = Textus::Store::Geometry.new(root).lock_path("build")
         @file = nil
       end
 

data/lib/textus/{ports → port}/clock.rb

@@ -1,5 +1,5 @@
 module Textus
-  module Ports
+  module Port
     # The wall clock. An instantiable class (ADR 0109) — uniform with the other
     # ports; `now` reads the system time. Callers that need a fixed time still
     # pass it as data via `Call#now`.

data/lib/textus/{ports → port}/publisher.rb

@@ -1,12 +1,12 @@
 require "fileutils"
 
 module Textus
-  module Ports
+  module Port
     # Publishes built artifacts from the store to repo-relative consumer paths.
     # Publish = copy + sentinel. The in-store file is already the consumer-shaped
     # artifact; no parsing or stripping.
     #
-    # Sentinel I/O is delegated to Textus::Ports::SentinelStore. Sentinels live
+    # Sentinel I/O is delegated to Textus::Port::SentinelStore. Sentinels live
     # under `<store_root>/.run/sentinels/` (runtime, git-ignored — ADR 0070) and
     # mirror the target's repo-relative layout so consumer directories aren't
     # polluted with `.textus-managed.json` siblings.
@@ -18,7 +18,7 @@ module Textus
         guard_clobber(source, target, store_root)
         File.delete(target) if File.symlink?(target)
         FileUtils.cp(source, target)
-        Textus::Ports::SentinelStore.new.write!(target: target, source: provenance_source, store_root: store_root)
+        Textus::Port::SentinelStore.new.write!(target: target, source: provenance_source, store_root: store_root)
       end
 
       # Removes a previously-published file and its sentinel. No-op unless the
@@ -27,7 +27,7 @@ module Textus
         return unless managed?(target, store_root)
 
         FileUtils.rm_f(target)
-        sentinel = Textus::Ports::SentinelStore.new.sentinel_path(target, store_root)
+        sentinel = Textus::Port::SentinelStore.new.sentinel_path(target, store_root)
         FileUtils.rm_f(sentinel)
       end
 
@@ -53,7 +53,7 @@ module Textus
       end
 
       def managed?(target, store_root)
-        File.exist?(Textus::Ports::SentinelStore.new.sentinel_path(target, store_root))
+        File.exist?(Textus::Port::SentinelStore.new.sentinel_path(target, store_root))
       end
     end
   end

data/lib/textus/{ports → port}/sentinel_store.rb

@@ -3,7 +3,7 @@ require "digest"
 require "fileutils"
 
 module Textus
-  module Ports
+  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.
@@ -39,14 +39,14 @@ module Textus
       def sentinel_path(target, store_root)
         repo_root = File.dirname(store_root)
         rel = relative_to(target, repo_root) || File.basename(target)
-        File.join(Textus::Layout.sentinels(store_root), rel + SUFFIX)
+        File.join(Textus::Store::Geometry.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::Layout.sentinels(store_root)
+        root = Textus::Store::Geometry.new(store_root).sentinels_root
         sdir = File.join(root, rel)
         return [] unless File.directory?(sdir)
 

data/lib/textus/{ports → port}/storage/file_stat.rb

@@ -1,5 +1,5 @@
 module Textus
-  module Ports
+  module Port
     module Storage
       # Read-only filesystem query port. The narrow interface that pure
       # domain logic (staleness checks, sentinel value) depends on, so the

data/lib/textus/{ports → port}/storage/file_store.rb

@@ -1,7 +1,7 @@
 require "fileutils"
 
 module Textus
-  module Ports
+  module Port
     module Storage
       # Pure filesystem I/O port. Wraps File/FileUtils/Etag with no knowledge
       # of envelopes, entries, schemas, or audit.
@@ -19,7 +19,7 @@ module Textus
 
         def exists?(path) = File.exist?(path)
 
-        def etag(path) = Etag.for_file(path)
+        def etag(path) = Value::Etag.for_file(path)
       end
     end
   end

data/lib/textus/port/store.rb

@@ -0,0 +1,93 @@
+# 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/{ports → port}/watcher_lock.rb

@@ -3,18 +3,18 @@
 require "socket"
 
 module Textus
-  module Ports
+  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::Layout.watcher_lock(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::Layout.watcher_lock(root)
+        path = Textus::Store::Geometry.new(root).lock_path("watcher")
         return false unless File.exist?(path)
 
         File.open(path, "r+") do |file|

data/lib/textus/produce/engine.rb

@@ -36,7 +36,7 @@ module Textus
         entry = @container.manifest.resolver.resolve(key).entry
         return unless entry.publish_tree || !Array(entry.publish_to).empty?
 
-        reader     = Textus::Envelope::Reader.from(container: @container)
+        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)
 

data/lib/textus/schema/tools.rb

@@ -6,7 +6,7 @@ module Textus
     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::Role::DEFAULT, from)
+        env = pure_get(store, Textus::Value::Role::DEFAULT, from)
         meta = env.meta
         schema = {
           "name" => name,
@@ -14,8 +14,9 @@ module Textus
           "optional" => [],
           "fields" => meta.each_with_object({}) { |(k, v), h| h[k] = { "type" => infer_type(v) } },
         }
-        FileUtils.mkdir_p(File.join(store.root, "schemas"))
-        target = File.join(store.root, "schemas", "#{name}.yaml")
+        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
@@ -25,7 +26,7 @@ module Textus
         schema = load_schema(store, name)
         drift = []
         store.manifest.resolver.enumerate.each do |row|
-          env = pure_get(store, Textus::Role::DEFAULT, row[:key])
+          env = pure_get(store, Textus::Value::Role::DEFAULT, row[:key])
           begin
             schema.validate!(env.meta)
           rescue SchemaViolation => e
@@ -85,9 +86,12 @@ module Textus
       # while inspecting/migrating entries (ADR 0062).
       def self.pure_get(store, role, key)
         scope = store.as(role)
-        Textus::Action::Get.new(key: key).call(
-          container: scope.container,
-          call: Textus::Call.build(role: role),
+        Value::Result.unwrap(
+          Textus::Action::Get.call(
+            container: scope.container,
+            call: Textus::Value::Call.build(role: role),
+            key: key,
+          ),
         )
       end
 

data/lib/textus/store/compositor.rb

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,43 @@
+# 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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,43 @@
+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