space-architect 8.0.0 → 9.1.0

data/lib/space_src/state/lock.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module Space::Src
-  module State
-    # Advisory process-level lock on a sidecar file derived from the
-    # state file path. Serializes overlapping `sync` runs so the
-    # later run bails cleanly rather than clobbering the in-flight
-    # run's state with a last-writer-wins atomic rename (CF10).
-    #
-    # The lockfile is a persistent zero-byte sentinel — never unlinked.
-    # Deleting a flock'd file while another fd holds it creates a race
-    # where both processes think they hold the lock on different inodes.
-    #
-    # `LOCK_NB` is for daemon safety, not reactor yielding: a blocking
-    # `LOCK_EX` would wedge a launchd tick forever behind a hung run.
-    # `flock` and the file I/O it guards are ordinary blocking syscalls
-    # with no Async scheduler hook — fine here, they're sub-millisecond
-    # on a local state dir, same as the rest of `State::Store`.
-    class Lock
-      NOT_ACQUIRED = :not_acquired
-
-      # Returns the sidecar lockfile path for a given state_file path.
-      def self.path_for(state_file)
-        "#{state_file}.lock"
-      end
-
-      # Acquires an exclusive non-blocking advisory lock on the sidecar
-      # lockfile. Creates the file (and its parent directory) if missing.
-      #
-      # Yields to the block and returns its value when the lock is
-      # acquired; releases the lock in an `ensure` so it is freed on
-      # normal return, explicit `return`, AND any escaping exception
-      # (including Interrupt / SignalException).
-      #
-      # Returns `NOT_ACQUIRED` *without* yielding when another process
-      # already holds the lock. The caller decides what to do (e.g.
-      # bail cleanly with a Success).
-      def self.acquire(state_file)
-        lock_path = path_for(state_file)
-        FileUtils.mkdir_p(File.dirname(lock_path))
-        f = File.open(lock_path, File::RDWR | File::CREAT)
-        # Everything that can raise — `flock` itself can (EINTR on a
-        # signal, ENOLCK on some filesystems) — runs inside the `begin`,
-        # so the `ensure` always closes the fd (no leak). Closing the fd
-        # releases the lock (it lives on the open file description), so
-        # no explicit LOCK_UN is needed — and `close` can't be skipped
-        # by a raising unlock.
-        begin
-          return NOT_ACQUIRED unless f.flock(File::LOCK_EX | File::LOCK_NB)
-          yield
-        ensure
-          f.close
-        end
-      end
-    end
-  end
-end

data/lib/space_src/state/store.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "fileutils"
-require "time"
-require "dry/monads"
-
-module Space::Src
-  module State
-    # Machine-managed state at $XDG_STATE_HOME/space-src/state.yaml.
-    # Never hand-edited (per PRD §3.2). Per-repo + per-org records with
-    # a fixed status enum; the store validates the enum and timestamp
-    # format on write.
-    class Store
-      extend Dry::Monads[:result]
-
-      STATUSES = %w[clean dirty diverged detached wrong_branch missing error].freeze
-
-      Repo = Data.define(:default_branch, :last_fetch_at, :last_synced_at, :status, :last_error) do
-        def initialize(default_branch: nil, last_fetch_at: nil, last_synced_at: nil, status: nil, last_error: nil)
-          super
-        end
-
-        def to_h_compact
-          {
-            "default_branch" => default_branch,
-            "last_fetch_at" => format_time(last_fetch_at),
-            "last_synced_at" => format_time(last_synced_at),
-            "status" => status,
-            "last_error" => last_error
-          }.compact
-        end
-
-        private
-
-        def format_time(t)
-          t.respond_to?(:iso8601) ? t.iso8601 : t
-        end
-      end
-
-      Org = Data.define(:last_listed_at, :repo_count, :last_error) do
-        def initialize(last_listed_at: nil, repo_count: 0, last_error: nil)
-          super
-        end
-
-        def to_h_compact
-          {
-            "last_listed_at" => format_time(last_listed_at),
-            "repo_count" => repo_count,
-            "last_error" => last_error
-          }.compact
-        end
-
-        private
-
-        # `last_listed_at` may arrive as a Time (fresh from the
-        # engine) or as a String (round-tripped from YAML, since
-        # `to_h_compact` always emits the iso8601 form on
-        # write). Both forms are written as the same string on
-        # the next emit; the helper accepts either.
-        def format_time(t)
-          return nil if t.nil?
-          t.respond_to?(:iso8601) ? t.iso8601 : t
-        end
-      end
-
-      def self.load(path)
-        raw = read_yaml(path)
-        Success(build_state(raw))
-      end
-
-      def self.write(path, state)
-        validation = validate(state)
-        return validation if validation.failure?
-
-        FileUtils.mkdir_p(File.dirname(path))
-        tmp = "#{path}.tmp.#{Process.pid}"
-        begin
-          File.write(tmp, emit(state))
-          File.rename(tmp, path)
-        ensure
-          File.delete(tmp) if File.exist?(tmp)
-        end
-        Success(state)
-      end
-
-      def self.validate(state)
-        state.repos.each do |key, repo|
-          unless STATUSES.include?(repo.status)
-            return Failure({repos: {key => {status: ["must be one of: #{STATUSES.join(", ")}"]}}})
-          end
-        end
-        Success(state)
-      end
-
-      def self.read_yaml(path)
-        return {} unless File.exist?(path)
-        # Time class permitted because state.yaml stores ISO8601
-        # timestamps; Psych will deserialize them as Time when the
-        # scalar is tagged. No other arbitrary classes allowed.
-        YAML.safe_load_file(path, permitted_classes: [Symbol, Time], aliases: false) || {}
-      end
-
-      def self.build_state(raw)
-        repos = (raw["repos"] || {}).each_with_object({}) do |(key, attrs), acc|
-          acc[key] = Repo.new(
-            default_branch: attrs["default_branch"],
-            last_fetch_at: attrs["last_fetch_at"],
-            last_synced_at: attrs["last_synced_at"],
-            status: attrs["status"],
-            last_error: attrs["last_error"]
-          )
-        end
-        orgs = (raw["orgs"] || {}).each_with_object({}) do |(key, attrs), acc|
-          acc[key] = Org.new(
-            last_listed_at: attrs["last_listed_at"],
-            repo_count: attrs["repo_count"] || 0,
-            last_error: attrs["last_error"]
-          )
-        end
-        State.new(repos: repos, orgs: orgs)
-      end
-
-      # State value object — top-level container.
-      State = Data.define(:repos, :orgs) do
-        def initialize(repos: {}, orgs: {})
-          super
-        end
-      end
-
-      def self.emit(state)
-        payload = {
-          "repos" => state.repos.each_with_object({}) { |(k, v), acc| acc[k] = v.to_h_compact },
-          "orgs" => state.orgs.each_with_object({}) { |(k, v), acc| acc[k] = v.to_h_compact }
-        }
-        YAML.dump(payload, line_width: -1)
-      end
-    end
-  end
-end