textus 0.4.0 → 0.5.0

data/lib/textus/store.rb

@@ -1,13 +1,8 @@
 require "fileutils"
 require "securerandom"
-require "time"
-require "timeout"
 
 module Textus
-  # rubocop:disable Metrics/ClassLength
   class Store
-    HOOK_TIMEOUT_SECONDS = 2
-
     attr_reader :root, :manifest, :registry
 
     # A Textus UID: 16 lowercase hex chars (SecureRandom.hex(8)). Not a UUID —
@@ -82,18 +77,18 @@ module Textus
 
       raw = File.binread(path)
       parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-      fm = parsed["frontmatter"]
+      meta = parsed["_meta"]
       content = parsed["content"]
-      enforce_name_match!(path, fm, mentry.format)
+      enforce_name_match!(path, meta, mentry.format)
       schema = schema_for(mentry.schema)
       if schema
         case mentry.format
-        when "markdown" then schema.validate!(fm)
+        when "markdown" then schema.validate!(meta)
         when "json", "yaml" then schema.validate!(content || {})
           # text: schema forbidden by manifest validation
         end
       end
-      build_envelope(key, mentry, path, fm, parsed["body"], Etag.for_bytes(raw), content: content)
+      build_envelope(key, mentry, path, meta, parsed["body"], Etag.for_bytes(raw), content: content)
     end
 
     def where(key)
@@ -131,30 +126,30 @@ module Textus
     end
 
     # rubocop:disable Metrics/ParameterLists
-    def put(key, frontmatter: nil, body: nil, content: nil, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
+    def put(key, meta: nil, body: nil, content: nil, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
       # rubocop:enable Metrics/ParameterLists
       @manifest.validate_key!(key)
       mentry, path, = @manifest.resolve(key)
       writers = @manifest.zone_writers(mentry.zone)
       raise WriteForbidden.new(key, mentry.zone, writers: writers) unless writers.include?(as)
 
-      frontmatter ||= {}
+      meta ||= {}
       strategy = Entry.for_format(mentry.format)
 
       existing_uid = existing_uid_for(mentry, path)
-      frontmatter, content = ensure_uid(mentry.format, frontmatter, content, existing_uid)
+      meta, content = ensure_uid(mentry.format, meta, content, existing_uid)
 
-      bytes, eff_fm, eff_body, eff_content = serialize_for_put(
+      bytes, eff_meta, eff_body, eff_content = serialize_for_put(
         mentry: mentry, path: path, strategy: strategy,
-        frontmatter: frontmatter, body: body, content: content
+        meta: meta, body: body, content: content
       )
 
-      enforce_name_match!(path, eff_fm, mentry.format)
+      enforce_name_match!(path, eff_meta, mentry.format)
 
       schema = schema_for(mentry.schema)
       if schema
         case mentry.format
-        when "markdown" then schema.validate!(eff_fm)
+        when "markdown" then schema.validate!(eff_meta)
         when "json", "yaml" then schema.validate!(eff_content || {})
         end
       end
@@ -166,7 +161,7 @@ module Textus
       File.binwrite(path, bytes)
       etag_after = Etag.for_bytes(bytes)
       audit_log.append(role: as, verb: "put", key: key, etag_before: etag_before, etag_after: etag_after)
-      envelope = build_envelope(key, mentry, path, eff_fm, eff_body, etag_after, content: eff_content)
+      envelope = build_envelope(key, mentry, path, eff_meta, eff_body, etag_after, content: eff_content)
       fire_event(:put, key: key, envelope: envelope) unless suppress_events
       envelope
     end
@@ -186,22 +181,8 @@ module Textus
       { "protocol" => PROTOCOL, "ok" => true, "key" => key, "deleted" => true }
     end
 
-    def fire_event(event, **kwargs)
-      view = StoreView.new(self)
-      @registry.hooks(event).each do |entry|
-        name = entry[:name]
-        Timeout.timeout(HOOK_TIMEOUT_SECONDS) { entry[:callable].call(store: view, **kwargs) }
-      rescue StandardError => e
-        extras = { "event" => event.to_s, "hook" => name.to_s, "error" => "#{e.class}: #{e.message}" }
-        extras["target_key"]  = kwargs[:target_key]  if kwargs.key?(:target_key)
-        extras["pending_key"] = kwargs[:pending_key] if kwargs.key?(:pending_key)
-        audit_log.append(
-          role: "script", verb: "event_error",
-          key: kwargs[:key] || kwargs[:target_key] || kwargs[:pending_key] || "-",
-          etag_before: nil, etag_after: nil,
-          extras: extras
-        )
-      end
+    def fire_event(event, **)
+      Events.new(self).call(event, **)
     end
 
     def accept(key, as:)
@@ -213,121 +194,12 @@ module Textus
     def published      = Dependencies.published_of(@manifest)
 
     def validate_all
-      violations = []
-      @manifest.enumerate.each do |row|
-        begin
-          get(row[:key])
-        rescue Textus::Error => e
-          violations << { "key" => row[:key], "code" => e.code, "message" => e.message }
-        end
-      end
-
-      @manifest.enumerate.each do |row|
-        mentry = row[:manifest_entry]
-        next unless mentry.schema
-
-        schema = schema_for(mentry.schema)
-        next unless schema
-
-        env = begin
-          get(row[:key])
-        rescue StandardError
-          next
-        end
-        last_writer = audit_log.last_writer_for(row[:key])
-        next if last_writer.nil?
-
-        env["frontmatter"].each_key do |field|
-          owner = schema.maintained_by(field)
-          next if owner.nil?
-          next if last_writer == owner
-          next if last_writer == "human"
-
-          violations << {
-            "key" => row[:key],
-            "code" => "role_authority",
-            "field" => field,
-            "expected" => owner,
-            "last_writer" => last_writer,
-          }
-        end
-      end
-
-      { "protocol" => PROTOCOL, "ok" => violations.empty?, "violations" => violations }
+      Validator.new(self).call
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
     def stale(prefix: nil, zone: nil)
-      out = []
-      @manifest.entries.each do |mentry|
-        next unless mentry.zone == "derived"
-        next if zone && mentry.zone != zone
-
-        gen = mentry.generator
-        next unless gen
-        next if prefix && !(mentry.key == prefix || mentry.key.start_with?("#{prefix}."))
-
-        path = path_for_entry(mentry)
-
-        unless File.exist?(path)
-          out << stale_row(mentry, path, "derived entry has never been generated")
-          next
-        end
-
-        raw = File.binread(path)
-        parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-        generated_at = parsed["frontmatter"].dig("generated", "at")
-        unless generated_at
-          out << stale_row(mentry, path, "missing generated.at frontmatter")
-          next
-        end
-        gen_time = begin
-          Time.parse(generated_at.to_s)
-        rescue StandardError
-          nil
-        end
-        unless gen_time
-          out << stale_row(mentry, path, "unparseable generated.at: #{generated_at.inspect}")
-          next
-        end
-
-        offender = newest_source_after(gen, gen_time)
-        out << stale_row(mentry, path, "source '#{offender}' modified after generated.at") if offender
-      end
-
-      @manifest.entries.each do |mentry|
-        next unless mentry.action
-        next if zone && mentry.zone != zone
-        next if prefix && !(mentry.key == prefix || mentry.key.start_with?("#{prefix}."))
-
-        ttl = parse_ttl(mentry.ttl)
-        next unless ttl
-
-        path = path_for_entry(mentry)
-
-        unless File.exist?(path)
-          out << intake_stale_row(mentry, path, "never refreshed")
-          next
-        end
-
-        fm = Entry.for_format(mentry.format).parse(File.binread(path), path: path)["frontmatter"]
-        last_str = fm["last_refreshed_at"]
-        if last_str.nil?
-          out << intake_stale_row(mentry, path, "never refreshed (no last_refreshed_at)")
-          next
-        end
-
-        last = begin
-          Time.parse(last_str.to_s)
-        rescue StandardError
-          nil
-        end
-        out << intake_stale_row(mentry, path, "ttl exceeded (#{ttl}s)") if last.nil? || (Time.now - last) > ttl
-      end
-
-      out
+      Staleness.new(self).call(prefix: prefix, zone: zone)
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
 
     # Returns the Textus UID for a key (or nil if the entry has none yet).
     # Raises UnknownKey if the key doesn't resolve to a real file.
@@ -339,223 +211,56 @@ module Textus
     # Move an entry from old_key to new_key within the same zone. Preserves
     # uid (minting one first if absent), validates both keys against the
     # manifest, refuses to clobber, and writes one mv audit row.
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def mv(old_key, new_key, as: Role::DEFAULT, dry_run: false)
-      @manifest.validate_key!(old_key)
-      @manifest.validate_key!(new_key)
-      raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
-
-      old_mentry, old_path, = @manifest.resolve(old_key)
-      raise UnknownKey.new(old_key) unless File.exist?(old_path)
-
-      new_mentry, new_path, = @manifest.resolve(new_key)
-
-      if old_mentry.zone != new_mentry.zone
-        raise UsageError.new(
-          "mv: cross-zone move refused (#{old_mentry.zone} → #{new_mentry.zone}). " \
-          "Use put+delete for cross-zone moves.",
-        )
-      end
-      if old_mentry.format != new_mentry.format
-        raise UsageError.new(
-          "mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.",
-        )
-      end
-
-      writers = @manifest.zone_writers(old_mentry.zone)
-      raise WriteForbidden.new(old_key, old_mentry.zone, writers: writers) unless writers.include?(as)
-
-      raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if File.exist?(new_path)
-
-      # Mint uid before the move so the audit row carries it.
-      pre_env = get(old_key)
-      current_uid = pre_env["uid"]
-      etag_before = pre_env["etag"]
-
-      if dry_run
-        return {
-          "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
-          "from_key" => old_key, "to_key" => new_key,
-          "from_path" => old_path, "to_path" => new_path,
-          "uid" => current_uid
-        }
-      end
-
-      if current_uid.nil?
-        # Write the uid in place first so the source file carries it before mv.
-        pre_env = put(old_key,
-                      frontmatter: pre_env["frontmatter"],
-                      body: pre_env["body"],
-                      content: pre_env["content"],
-                      as: as,
-                      suppress_events: true)
-        current_uid = pre_env["uid"]
-        etag_before = pre_env["etag"]
-      end
-
-      FileUtils.mkdir_p(File.dirname(new_path))
-      FileUtils.mv(old_path, new_path)
-      rewrite_name_for_mv!(new_mentry, new_path, new_key)
-      etag_after = Etag.for_file(new_path)
-
-      audit_log.append(
-        role: as, verb: "mv", key: new_key,
-        etag_before: etag_before, etag_after: etag_after,
-        extras: {
-          "from_key" => old_key, "to_key" => new_key,
-          "from_path" => old_path, "to_path" => new_path,
-          "uid" => current_uid
-        }
-      )
+      Mover.new(self).call(old_key, new_key, as: as, dry_run: dry_run)
+    end
 
-      env = get(new_key)
-      {
-        "protocol" => PROTOCOL, "ok" => true,
-        "from_key" => old_key, "to_key" => new_key,
-        "from_path" => old_path, "to_path" => new_path,
-        "uid" => current_uid,
-        "envelope" => env
-      }
+    def audit_log
+      @audit_log ||= AuditLog.new(@root)
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     private
 
-    # If the moved file carries a `name:` field (markdown) or `_meta.name`
-    # (json/yaml), rewrite it to the new basename so enforce_name_match! stays
-    # happy on the next read. Only touches the bytes when name actually changes.
-    def rewrite_name_for_mv!(mentry, new_path, new_key)
-      strategy = Entry.for_format(mentry.format)
-      raw = File.binread(new_path)
-      parsed = strategy.parse(raw, path: new_path)
-      basename = new_key.split(".").last
-
-      case mentry.format
-      when "markdown"
-        fm = parsed["frontmatter"] || {}
-        return unless fm.is_a?(Hash) && fm["name"].is_a?(String) && fm["name"] != basename
-
-        fm = fm.merge("name" => basename)
-        File.binwrite(new_path, strategy.serialize(frontmatter: fm, body: parsed["body"]))
-      when "json", "yaml"
-        content = parsed["content"]
-        return unless content.is_a?(Hash) && content["_meta"].is_a?(Hash) &&
-                      content["_meta"]["name"].is_a?(String) && content["_meta"]["name"] != basename
-
-        meta = content["_meta"].merge("name" => basename)
-        content = { "_meta" => meta }.merge(content.except("_meta"))
-        File.binwrite(new_path, strategy.serialize(frontmatter: {}, body: "", content: content))
-      end
-    end
-
     def existing_uid_for(mentry, path)
       return nil unless File.exist?(path)
 
       raw = File.binread(path)
       parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-      extract_uid(mentry.format, parsed["frontmatter"], parsed["content"])
+      extract_uid(parsed["_meta"])
     rescue StandardError
       nil
     end
 
     # Ensures the payload carries a uid: preserve existing, else mint.
-    # Returns [frontmatter, content] possibly mutated.
-    def ensure_uid(format, frontmatter, content, existing_uid)
+    # Returns [meta, content] possibly mutated.
+    def ensure_uid(format, meta, content, existing_uid)
       case format
-      when "markdown"
-        fm = frontmatter.is_a?(Hash) ? frontmatter.dup : {}
-        fm["uid"] = existing_uid || Store.mint_uid unless fm["uid"].is_a?(String) && !fm["uid"].empty?
-        [fm, content]
-      when "json", "yaml"
-        c = content.is_a?(Hash) ? content.dup : nil
-        if c
-          meta = c["_meta"].is_a?(Hash) ? c["_meta"].dup : {}
-          meta["uid"] = existing_uid || Store.mint_uid if !meta["uid"].is_a?(String) || meta["uid"].empty?
-          # Keep _meta first for etag stability.
-          c = { "_meta" => meta }.merge(c.except("_meta"))
-        end
-        [frontmatter, c]
+      when "markdown", "json", "yaml"
+        m = meta.is_a?(Hash) ? meta.dup : {}
+        m["uid"] = existing_uid || Store.mint_uid unless m["uid"].is_a?(String) && !m["uid"].empty?
+        [m, content]
       else
         # text: no uid channel
-        [frontmatter, content]
+        [meta, content]
       end
     end
 
-    def audit_log
-      @audit_log ||= AuditLog.new(@root)
-    end
+    def enforce_name_match!(path, meta, format)
+      return unless %w[markdown json yaml].include?(format)
+      return unless meta.is_a?(Hash) && meta["name"]
 
-    def path_for_entry(mentry)
-      primary_ext = Entry.for_format(mentry.format).extensions.first
-      if File.extname(mentry.path) == ""
-        File.join(@root, "zones", mentry.path + primary_ext)
-      else
-        File.join(@root, "zones", mentry.path)
-      end
-    end
+      ext = Entry.for_format(format).extensions.first
+      basename = File.basename(path, ext)
+      return if meta["name"] == basename
 
-    def newest_source_after(gen, gen_time)
-      Array(gen["sources"]).each do |src|
-        if src.match?(/\A[a-z0-9.][a-z0-9._-]*\z/) && !src.include?("/")
-          @manifest.enumerate(prefix: src).each do |row|
-            return src if File.mtime(row[:path]) > gen_time
-          end
-        else
-          abs = File.absolute_path?(src) ? src : File.join(File.dirname(@root), src)
-          if File.directory?(abs)
-            Dir.glob(File.join(abs, "**", "*")).each do |fp|
-              next unless File.file?(fp)
-              return src if File.mtime(fp) > gen_time
-            end
-          elsif File.exist?(abs)
-            return src if File.mtime(abs) > gen_time
-          end
-        end
-      end
-      nil
-    end
-
-    def parse_ttl(s)
-      return nil unless s
-
-      m = s.to_s.match(/\A(\d+)([smhd])\z/) or return nil
-      n = m[1].to_i
-      case m[2]
-      when "s" then n
-      when "m" then n * 60
-      when "h" then n * 3600
-      when "d" then n * 86_400
-      end
+      raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
     end
 
-    def intake_stale_row(mentry, path, reason)
-      { "key" => mentry.key, "path" => path, "action" => mentry.action, "reason" => reason }
-    end
-
-    def stale_row(mentry, path, reason)
-      {
-        "key" => mentry.key,
-        "path" => path,
-        "generator" => mentry.generator,
-        "reason" => reason,
-      }
-    end
-
-    def enforce_name_match!(path, fm, format)
-      # Name<->basename check only meaningful for markdown frontmatter.
-      return unless format == "markdown"
-
-      basename = File.basename(path, ".md")
-      return unless fm.is_a?(Hash) && fm["name"] && fm["name"] != basename
-
-      raise BadFrontmatter.new(path, "frontmatter name '#{fm["name"]}' does not match basename '#{basename}'")
-    end
-
-    def serialize_for_put(mentry:, path:, strategy:, frontmatter:, body:, content:)
+    def serialize_for_put(mentry:, path:, strategy:, meta:, body:, content:)
       case mentry.format
       when "markdown", "text"
-        bytes = strategy.serialize(frontmatter: frontmatter, body: body.to_s)
-        [bytes, frontmatter, body.to_s, nil]
+        bytes = strategy.serialize(meta: meta, body: body.to_s)
+        [bytes, meta, body.to_s, nil]
       when "json", "yaml"
         raise UsageError.new("put for #{mentry.format} requires content: or body:") if content.nil? && (body.nil? || body.to_s.empty?)
 
@@ -566,13 +271,12 @@ module Textus
           rescue BadFrontmatter => e
             raise BadContent.new(path, "bad_content: #{e.message}")
           end
+          eff_meta = parsed["_meta"]
           eff_content = parsed["content"]
-          eff_fm = eff_content.is_a?(Hash) && eff_content["_meta"].is_a?(Hash) ? eff_content["_meta"] : {}
-          [body.to_s, eff_fm, body.to_s, eff_content]
+          [body.to_s, eff_meta, body.to_s, eff_content]
         else
-          bytes = strategy.serialize(frontmatter: {}, body: "", content: content)
-          eff_fm = content.is_a?(Hash) && content["_meta"].is_a?(Hash) ? content["_meta"] : (frontmatter || {})
-          [bytes, eff_fm, bytes, content]
+          bytes = strategy.serialize(meta: meta, body: "", content: content)
+          [bytes, meta, bytes, content]
         end
       else
         raise UsageError.new("unknown format #{mentry.format.inspect}")
@@ -580,7 +284,7 @@ module Textus
     end
 
     # rubocop:disable Metrics/ParameterLists
-    def build_envelope(key, mentry, path, fm, body, etag, content: nil)
+    def build_envelope(key, mentry, path, meta, body, etag, content: nil)
       # rubocop:enable Metrics/ParameterLists
       env = {
         "protocol" => PROTOCOL,
@@ -589,29 +293,20 @@ module Textus
         "owner" => mentry.owner,
         "path" => path,
         "format" => mentry.format,
-        "frontmatter" => fm,
+        "_meta" => meta,
         "body" => body,
         "etag" => etag,
         "schema_ref" => mentry.schema,
-        "uid" => extract_uid(mentry.format, fm, content),
+        "uid" => extract_uid(meta),
       }
       env["content"] = content unless content.nil?
       env
     end
 
-    # Pull a Textus UID out of the parsed entry shape per format.
-    # markdown: frontmatter["uid"]; json/yaml: content["_meta"]["uid"]; text: nil.
-    def extract_uid(format, fm, content)
-      case format
-      when "markdown"
-        v = fm.is_a?(Hash) ? fm["uid"] : nil
-        v.is_a?(String) ? v : nil
-      when "json", "yaml"
-        meta = content.is_a?(Hash) ? content["_meta"] : nil
-        v = meta.is_a?(Hash) ? meta["uid"] : nil
-        v.is_a?(String) ? v : nil
-      end
+    # Pull a Textus UID out of the unified _meta hash.
+    def extract_uid(meta)
+      v = meta.is_a?(Hash) ? meta["uid"] : nil
+      v.is_a?(String) ? v : nil
     end
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.4.0"
-  PROTOCOL = "textus/1"
+  VERSION = "0.5.0"
+  PROTOCOL = "textus/2"
 end

data/lib/textus.rb

@@ -12,8 +12,13 @@ require_relative "textus/entry/text"
 require_relative "textus/entry"
 require_relative "textus/schema"
 require_relative "textus/key_distance"
+require_relative "textus/manifest_entry"
 require_relative "textus/manifest"
 require_relative "textus/dependencies"
+require_relative "textus/store/events"
+require_relative "textus/store/validator"
+require_relative "textus/store/staleness"
+require_relative "textus/store/mover"
 require_relative "textus/store"
 require_relative "textus/store_view"
 require_relative "textus/refresh"
@@ -26,6 +31,39 @@ require_relative "textus/proposal"
 require_relative "textus/init"
 require_relative "textus/schema_tools"
 require_relative "textus/migrate_keys"
+require_relative "textus/migrate_v2"
 require_relative "textus/doctor"
 require_relative "textus/intro"
+# CLI verb command objects — base class first, then verbs alphabetically.
+require_relative "textus/cli/verb"
+require_relative "textus/cli/deprecated_alias"
+require_relative "textus/cli/accept"
+require_relative "textus/cli/action"
+require_relative "textus/cli/build"
+require_relative "textus/cli/delete"
+require_relative "textus/cli/deps"
+require_relative "textus/cli/doctor"
+require_relative "textus/cli/extensions"
+require_relative "textus/cli/get"
+require_relative "textus/cli/init"
+require_relative "textus/cli/intro"
+require_relative "textus/cli/list"
+require_relative "textus/cli/migrate_keys"
+require_relative "textus/cli/migrate"
+require_relative "textus/cli/mv"
+require_relative "textus/cli/published"
+require_relative "textus/cli/put"
+require_relative "textus/cli/rdeps"
+require_relative "textus/cli/refresh"
+require_relative "textus/cli/schema"
+require_relative "textus/cli/schema_diff"
+require_relative "textus/cli/schema_init"
+require_relative "textus/cli/schema_migrate"
+require_relative "textus/cli/stale"
+require_relative "textus/cli/uid"
+require_relative "textus/cli/where"
+require_relative "textus/cli/group"
+require_relative "textus/cli/key_group"
+require_relative "textus/cli/schema_group"
+require_relative "textus/cli/extension_group"
 require_relative "textus/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Patrick
@@ -99,6 +99,37 @@ files:
 - lib/textus/builder.rb
 - lib/textus/builtin_actions.rb
 - lib/textus/cli.rb
+- lib/textus/cli/accept.rb
+- lib/textus/cli/action.rb
+- lib/textus/cli/build.rb
+- lib/textus/cli/delete.rb
+- lib/textus/cli/deprecated_alias.rb
+- lib/textus/cli/deps.rb
+- lib/textus/cli/doctor.rb
+- lib/textus/cli/extension_group.rb
+- lib/textus/cli/extensions.rb
+- lib/textus/cli/get.rb
+- lib/textus/cli/group.rb
+- lib/textus/cli/init.rb
+- lib/textus/cli/intro.rb
+- lib/textus/cli/key_group.rb
+- lib/textus/cli/list.rb
+- lib/textus/cli/migrate.rb
+- lib/textus/cli/migrate_keys.rb
+- lib/textus/cli/mv.rb
+- lib/textus/cli/published.rb
+- lib/textus/cli/put.rb
+- lib/textus/cli/rdeps.rb
+- lib/textus/cli/refresh.rb
+- lib/textus/cli/schema.rb
+- lib/textus/cli/schema_diff.rb
+- lib/textus/cli/schema_group.rb
+- lib/textus/cli/schema_init.rb
+- lib/textus/cli/schema_migrate.rb
+- lib/textus/cli/stale.rb
+- lib/textus/cli/uid.rb
+- lib/textus/cli/verb.rb
+- lib/textus/cli/where.rb
 - lib/textus/dependencies.rb
 - lib/textus/doctor.rb
 - lib/textus/entry.rb
@@ -114,7 +145,9 @@ files:
 - lib/textus/intro.rb
 - lib/textus/key_distance.rb
 - lib/textus/manifest.rb
+- lib/textus/manifest_entry.rb
 - lib/textus/migrate_keys.rb
+- lib/textus/migrate_v2.rb
 - lib/textus/mustache.rb
 - lib/textus/projection.rb
 - lib/textus/proposal.rb
@@ -124,6 +157,10 @@ files:
 - lib/textus/schema.rb
 - lib/textus/schema_tools.rb
 - lib/textus/store.rb
+- lib/textus/store/events.rb
+- lib/textus/store/mover.rb
+- lib/textus/store/staleness.rb
+- lib/textus/store/validator.rb
 - lib/textus/store_view.rb
 - lib/textus/version.rb
 homepage: https://github.com/patrick204nqh/textus