space-architect 1.1.0

data/vendor/repo-tender/lib/space_architect/pristine/cli/org.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "dry/monads"
+require "space_architect/pristine/cli"
+require "space_architect/pristine/ui/mode"
+require "space_architect/pristine/cli/options"
+
+module SpaceArchitect::Pristine
+  module CLI
+    # `org` command group: add / remove / list tracked orgs.
+    # Same shape as `repo` but against `Config::OrgRef` (host + name
+    # + two bool flags). The host defaults to "github.com" per
+    # PRD §3.1 when omitted (so `org add socketry` works as well as
+    # `org add github.com/socketry`).
+    module Org
+      module Helpers
+        module_function
+
+        # Parse an org ref string. Accepts "github.com/socketry" or
+        # bare "socketry" (defaults host to github.com). Anything
+        # with 3+ parts is rejected (org has only host + name).
+        def parse_ref(name, include_archived: false, include_forks: false, ignored_repos: [])
+          parts = name.to_s.split("/")
+          case parts.length
+          when 1
+            org = parts[0]
+            return Dry::Monads::Failure("invalid org reference: empty name in #{name.inspect}") if org.empty?
+            Dry::Monads::Success(Config::OrgRef.new(
+              host: Config::DEFAULT_HOST,
+              name: org,
+              include_archived: include_archived,
+              include_forks: include_forks,
+              ignored_repos: ignored_repos
+            ))
+          when 2
+            host, n = parts
+            return Dry::Monads::Failure("invalid org reference: empty host in #{name.inspect}") if host.empty?
+            return Dry::Monads::Failure("invalid org reference: empty name in #{name.inspect}") if n.empty?
+            Dry::Monads::Success(Config::OrgRef.new(
+              host: host,
+              name: n,
+              include_archived: include_archived,
+              include_forks: include_forks,
+              ignored_repos: ignored_repos
+            ))
+          else
+            Dry::Monads::Failure("invalid org reference: #{name.inspect} (expected \"<name>\" or \"<host>/<name>\")")
+          end
+        end
+
+        def same_org?(a, b) = a.host == b.host && a.name == b.name
+        def format_ref(o) = "#{o.host}/#{o.name}"
+        def format_failure(f) = f.is_a?(Hash) ? f.inspect : f.to_s
+
+        def format_ignored(o)
+          return "" if o.ignored_repos.empty?
+          " ignored_repos=#{o.ignored_repos.inspect}"
+        end
+
+        def fail_with(cmd, msg)
+          cmd.send(:err).puts msg
+          SpaceArchitect::Pristine::CLI.record_outcome(Outcome.new(exit_code: 1, message: msg))
+        end
+      end
+
+      class Add < Dry::CLI::Command
+        include Helpers
+        include GlobalOptions
+
+        desc "Add a tracked org (idempotent on host/name)"
+        argument :name, required: true,
+          desc: "Org identity as <name> or <host>/<name> (host defaults to github.com)"
+        option :include_archived, type: :boolean, default: false,
+          desc: "Include archived repos when expanding the org"
+        option :include_forks, type: :boolean, default: false,
+          desc: "Include forks when expanding the org"
+        option :ignored_repos, type: :array, default: [],
+          desc: "Repos to exclude from expansion (bare name or owner/name)"
+
+        def call(name:, include_archived: false, include_forks: false, ignored_repos: [], plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          pastel = Pastel.new(enabled: mode.color)
+
+          parsed = parse_ref(name,
+            include_archived: include_archived,
+            include_forks: include_forks,
+            ignored_repos: ignored_repos)
+          return fail_with(self, parsed.failure) if parsed.failure?
+
+          new_ref = parsed.success
+          paths = CLI.make_paths
+          config = Config::Store.load(paths.config_file).success
+
+          if config.orgs.any? { |o| same_org?(o, new_ref) }
+            out.puts pastel.yellow("already tracked: #{format_ref(new_ref)}" \
+              " (include_archived=#{new_ref.include_archived}, include_forks=#{new_ref.include_forks})" \
+              "#{format_ignored(new_ref)}")
+            return CLI.record_outcome(Outcome.new(exit_code: 0))
+          end
+
+          result = Config::Store.update(paths.config_file) do |c|
+            Config::Store.with(c, orgs: c.orgs + [new_ref])
+          end
+          if result.failure?
+            return fail_with(self, "failed to update config: #{format_failure(result.failure)}")
+          end
+
+          out.puts pastel.green("added: #{format_ref(new_ref)}" \
+            " (include_archived=#{new_ref.include_archived}, include_forks=#{new_ref.include_forks})" \
+            "#{format_ignored(new_ref)}")
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+
+      class Remove < Dry::CLI::Command
+        include Helpers
+        include GlobalOptions
+
+        desc "Remove a tracked org (host/name)"
+        argument :name, required: true,
+          desc: "Org identity as <name> or <host>/<name> (host defaults to github.com)"
+
+        def call(name:, plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          # The flags don't affect the identity match for remove; we
+          # match on (host, name) only. This matches the user's
+          # expectation that "remove" targets the org, not the flag
+          # combination they added it with.
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          pastel = Pastel.new(enabled: mode.color)
+
+          parsed = parse_ref(name)
+          return fail_with(self, parsed.failure) if parsed.failure?
+
+          target = parsed.success
+          paths = CLI.make_paths
+          config = Config::Store.load(paths.config_file).success
+
+          kept = config.orgs.reject { |o| same_org?(o, target) }
+          if kept.size == config.orgs.size
+            return fail_with(self, "not tracked: #{format_ref(target)}")
+          end
+
+          result = Config::Store.update(paths.config_file) do |c|
+            Config::Store.with(c, orgs: kept)
+          end
+          if result.failure?
+            return fail_with(self, "failed to update config: #{format_failure(result.failure)}")
+          end
+
+          out.puts pastel.green("removed: #{format_ref(target)}")
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+
+      class List < Dry::CLI::Command
+        include Helpers
+        include GlobalOptions
+
+        desc "List tracked orgs"
+
+        def call(plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          pastel = Pastel.new(enabled: mode.color)
+
+          paths = CLI.make_paths
+          config = Config::Store.load(paths.config_file).success
+          if config.orgs.empty?
+            out.puts pastel.dim("(no tracked orgs)")
+          else
+            config.orgs.each do |o|
+              out.puts pastel.cyan("#{o.host}/#{o.name}" \
+                " (include_archived=#{o.include_archived}, include_forks=#{o.include_forks})" \
+                "#{format_ignored(o)}")
+            end
+          end
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+    end
+  end
+end
+
+SpaceArchitect::Pristine::CLI::Registry.register "org" do |prefix|
+  prefix.register "add", SpaceArchitect::Pristine::CLI::Org::Add
+  prefix.register "remove", SpaceArchitect::Pristine::CLI::Org::Remove
+  prefix.register "list", SpaceArchitect::Pristine::CLI::Org::List
+end

data/vendor/repo-tender/lib/space_architect/pristine/cli/repo.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "dry/monads"
+require "space_architect/pristine/cli"
+require "space_architect/pristine/ui/mode"
+require "space_architect/pristine/cli/options"
+
+module SpaceArchitect::Pristine
+  module CLI
+    # `repo` command group: add / remove / list tracked repos.
+    # Backed by Config::Store (the on-disk config.yaml is the
+    # source of truth — the CLI is just the CRUD interface).
+    module Repo
+      # Shared ref parser + formatters used by Add and Remove. Kept
+      # in a module-level Helpers so the parsing rules live in one
+      # place (the "invalid repo reference" message must be identical
+      # across add/remove for G3 consistency).
+      module Helpers
+        module_function
+
+        def parse_ref(ref)
+          parts = ref.to_s.split("/")
+          return Dry::Monads::Failure("invalid repo reference: #{ref.inspect} (expected host/owner/name)") if parts.length != 3
+          host, owner, name = parts
+          return Dry::Monads::Failure("invalid repo reference: empty host in #{ref.inspect}") if host.empty?
+          return Dry::Monads::Failure("invalid repo reference: empty owner in #{ref.inspect}") if owner.empty?
+          return Dry::Monads::Failure("invalid repo reference: empty name in #{ref.inspect}") if name.empty?
+          Dry::Monads::Success(Config::RepoRef.new(host: host, owner: owner, name: name))
+        end
+
+        def same_repo?(a, b)
+          a.host == b.host && a.owner == b.owner && a.name == b.name
+        end
+
+        def format_ref(r) = "#{r.host}/#{r.owner}/#{r.name}"
+
+        def format_failure(f) = f.is_a?(Hash) ? f.inspect : f.to_s
+
+        def fail_with(cmd, msg)
+          cmd.send(:err).puts msg
+          SpaceArchitect::Pristine::CLI.record_outcome(Outcome.new(exit_code: 1, message: msg))
+        end
+      end
+
+      # Add a tracked repo. Idempotent on the (host, owner, name)
+      # triple: adding the same ref twice prints "already tracked"
+      # and exits 0 (does NOT write a duplicate).
+      class Add < Dry::CLI::Command
+        include Helpers
+        include GlobalOptions
+
+        desc "Add a tracked repo (idempotent on host/owner/name)"
+        argument :ref, required: true,
+          desc: "Repo identity as host/owner/name (e.g. github.com/ruby/ruby)"
+
+        def call(ref:, plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          pastel = Pastel.new(enabled: mode.color)
+
+          parsed = parse_ref(ref)
+          return fail_with(self, parsed.failure) if parsed.failure?
+
+          new_ref = parsed.success
+          paths = CLI.make_paths
+          config = Config::Store.load(paths.config_file).success
+
+          if config.repos.any? { |r| same_repo?(r, new_ref) }
+            out.puts pastel.yellow("already tracked: #{format_ref(new_ref)}")
+            return CLI.record_outcome(Outcome.new(exit_code: 0))
+          end
+
+          result = Config::Store.update(paths.config_file) do |c|
+            Config::Store.with(c, repos: c.repos + [new_ref])
+          end
+
+          if result.failure?
+            return fail_with(self, "failed to update config: #{format_failure(result.failure)}")
+          end
+
+          out.puts pastel.green("added: #{format_ref(new_ref)}")
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+
+      # Remove a tracked repo. Exits 0 with a clear message if the
+      # ref was present; exits 1 with "not tracked" if it wasn't
+      # (and the config is untouched in that case).
+      class Remove < Dry::CLI::Command
+        include Helpers
+        include GlobalOptions
+
+        desc "Remove a tracked repo (host/owner/name)"
+        argument :ref, required: true,
+          desc: "Repo identity as host/owner/name (e.g. github.com/ruby/ruby)"
+
+        def call(ref:, plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          pastel = Pastel.new(enabled: mode.color)
+
+          parsed = parse_ref(ref)
+          return fail_with(self, parsed.failure) if parsed.failure?
+
+          target = parsed.success
+          paths = CLI.make_paths
+          config = Config::Store.load(paths.config_file).success
+
+          kept = config.repos.reject { |r| same_repo?(r, target) }
+          if kept.size == config.repos.size
+            return fail_with(self, "not tracked: #{format_ref(target)}")
+          end
+
+          result = Config::Store.update(paths.config_file) do |c|
+            Config::Store.with(c, repos: kept)
+          end
+          if result.failure?
+            return fail_with(self, "failed to update config: #{format_failure(result.failure)}")
+          end
+
+          out.puts pastel.green("removed: #{format_ref(target)}")
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+
+      # List tracked repos. One per line: "host/owner/name".
+      class List < Dry::CLI::Command
+        include GlobalOptions
+
+        desc "List tracked repos"
+
+        def call(plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          pastel = Pastel.new(enabled: mode.color)
+
+          paths = CLI.make_paths
+          config = Config::Store.load(paths.config_file).success
+          if config.repos.empty?
+            out.puts pastel.dim("(no tracked repos)")
+          else
+            config.repos.each do |r|
+              out.puts pastel.cyan("#{r.host}/#{r.owner}/#{r.name}")
+            end
+          end
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+    end
+  end
+end
+
+# Register the `repo` group + its subcommands. The block's `prefix`
+# is a Dry::CLI::Registry::Prefix proxy that namespaces the
+# subcommand names under "repo".
+SpaceArchitect::Pristine::CLI::Registry.register "repo" do |prefix|
+  prefix.register "add", SpaceArchitect::Pristine::CLI::Repo::Add
+  prefix.register "remove", SpaceArchitect::Pristine::CLI::Repo::Remove
+  prefix.register "list", SpaceArchitect::Pristine::CLI::Repo::List
+end

data/vendor/repo-tender/lib/space_architect/pristine/cli/status.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "space_architect/pristine/cli"
+require "space_architect/pristine/ui/mode"
+require "space_architect/pristine/cli/options"
+
+module SpaceArchitect::Pristine
+  module CLI
+    # `status` command: render a per-repo evergreen table from
+    # State::Store. Per G5, the rows must include each repo key
+    # with status, last_synced_at, and default_branch.
+    module Status
+      class Show < Dry::CLI::Command
+        include GlobalOptions
+
+        STATUS_COLORS = {
+          "clean" => :green,
+          "dirty" => :yellow,
+          "diverged" => :yellow,
+          "wrong_branch" => :yellow,
+          "detached" => :yellow,
+          "error" => :red
+        }.freeze
+
+        desc "Show the per-repo evergreen status table (from $XDG_STATE_HOME/repo-tender/state.yaml)"
+
+        def call(plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          pastel = Pastel.new(enabled: mode.color)
+
+          paths = CLI.make_paths
+          state = State::Store.load(paths.state_file).success
+
+          if state.repos.empty?
+            out.puts "(no repos in state — run `repo-tender sync` to populate)"
+            return CLI.record_outcome(Outcome.new(exit_code: 0))
+          end
+
+          # Tab-separated columns. The G5 assertion is on captured
+          # stdout containing each repo key and its status string —
+          # tab-separated is the most assertion-friendly (no width
+          # padding complexity, no ANSI codes).
+          out.puts ["REPO", "STATUS", "DEFAULT_BRANCH", "LAST_SYNCED_AT", "LAST_FETCH_AT"].join("\t")
+          state.repos.keys.sort.each do |key|
+            r = state.repos[key]
+            status_str = r.status.to_s
+            color = STATUS_COLORS[status_str]
+            styled_status = color ? pastel.decorate(status_str, color) : status_str
+            out.puts [
+              key,
+              styled_status,
+              r.default_branch.to_s,
+              format_time(r.last_synced_at),
+              format_time(r.last_fetch_at)
+            ].join("\t")
+          end
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+
+        private
+
+        def format_time(t)
+          return "" if t.nil?
+          t.respond_to?(:iso8601) ? t.iso8601 : t.to_s
+        end
+      end
+    end
+  end
+end
+
+SpaceArchitect::Pristine::CLI::Registry.register "status", SpaceArchitect::Pristine::CLI::Status::Show

data/vendor/repo-tender/lib/space_architect/pristine/cli/sync.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "space_architect/pristine/cli"
+require "space_architect/pristine/cli/repo"  # for Repo::Helpers.parse_ref
+require "space_architect/pristine/cli/options"
+require "space_architect/pristine/ui/mode"
+require "space_architect/pristine/ui/plain_reporter"
+require "space_architect/pristine/ui/json_reporter"
+require "space_architect/pristine/ui/interactive_reporter"
+
+module SpaceArchitect::Pristine
+  module CLI
+    # `sync` command: invoke Sync::Engine over the full config, or
+    # scope to a single repo with --repo.
+    #
+    # Scoping is implemented at the CLI layer (per gate G4): the
+    # CLI builds a filtered Config (Config::Store.with(config,
+    # repos: [match], orgs: [])) and passes it to the unchanged
+    # engine. Sync::Engine#call is (config:, paths:) — there is no
+    # scoping parameter on the engine, and the spec forbids editing
+    # sync/engine.rb in this slice.
+    module Sync
+      class Run < Dry::CLI::Command
+        include GlobalOptions
+
+        desc "Run one sync pass (use --repo to scope to a single tracked repo)"
+        option :repo, desc: "Scope to a single tracked repo (host/owner/name)"
+
+        def call(repo: nil, plain: nil, json: nil, no_color: nil, quiet: nil, **)
+          paths = CLI.make_paths
+          paths.ensure!
+          config = Config::Store.load(paths.config_file).success
+
+          # Log rotation pre-step (slice-4 gate G5). launchd owns
+          # the stdout/stderr redirect via StandardOutPath /
+          # StandardErrorPath; the sync process rotates those
+          # files at the start of each run so the previous run's
+          # log doesn't grow unbounded. The rotator renames the
+          # file to a timestamped archive (preserving bytes); the
+          # current process's inherited fd still points to the
+          # renamed file, so writes during this run succeed.
+          # launchd opens a fresh file at the original path on
+          # the next spawn. No-op when the log is missing or
+          # under-threshold (sync tests in G4 stay green).
+          rotate_plist_logs(paths)
+          if repo
+            target = scope_target(repo)
+            return fail_with(self, "invalid repo reference: #{repo.inspect} (expected host/owner/name)") if target.failure?
+
+            match = target.success
+            found = config.repos.find { |r| Repo::Helpers.same_repo?(r, match) }
+            if found.nil?
+              return fail_with(self, "no such tracked repo: #{Repo::Helpers.format_ref(match)}")
+            end
+            # Filtered config: only the one matched repo, no orgs
+            # (org expansion would discover other repos — that's
+            # exactly the G4 "other repo gets no state row" test
+            # path, so we explicitly empty orgs here).
+            config = Config::Store.with(config, repos: [found], orgs: [])
+            out.puts "scoping sync to: #{Repo::Helpers.format_ref(found)}"
+          end
+
+          mode = UI::Mode.resolve(
+            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
+            env: CLI.env,
+            out: out
+          )
+          reporter = if mode.format == :json
+            UI::JsonReporter.new(out)
+          elsif mode.animate
+            UI::InteractiveReporter.new(out, mode: mode)
+          else
+            UI::PlainReporter.new(out, mode: mode)
+          end
+
+          result = SpaceArchitect::Pristine::Sync::Engine.new(reporter: reporter).call(config: config, paths: paths)
+          if result.failure?
+            return fail_with(self, "sync failed: #{format_failure(result.failure)}")
+          end
+
+          new_state = result.success
+          n = new_state.repos.size
+          out.puts "synced #{n} repo(s)"
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+
+        private
+
+        def scope_target(repo)
+          Repo::Helpers.parse_ref(repo)
+        end
+
+        def format_failure(f) = f.is_a?(Hash) ? f.inspect : f.to_s
+
+        def fail_with(cmd, msg)
+          cmd.send(:err).puts msg
+          SpaceArchitect::Pristine::CLI.record_outcome(Outcome.new(exit_code: 1, message: msg))
+        end
+
+        # Default log-rotation threshold: 10 MiB. Tunable via the
+        # env var `REPO_TENDER_LOG_MAX_BYTES` (introspection /
+        # ops escape hatch). The LogRotator itself is unit-tested
+        # with an injected threshold (gate G5).
+        DEFAULT_LOG_MAX_BYTES = 10 * 1024 * 1024
+
+        def rotate_plist_logs(paths)
+          threshold = log_max_bytes
+          label = Launchd::Agent::DEFAULT_LABEL
+          [File.join(paths.log_dir, "#{label}.out.log"),
+            File.join(paths.log_dir, "#{label}.err.log")].each do |p|
+            SpaceArchitect::Pristine::LogRotator.call(p, threshold_bytes: threshold)
+          end
+        end
+
+        # CF6 (Slice 5): defensively parse the
+        # `REPO_TENDER_LOG_MAX_BYTES` env var so a malformed
+        # operator value (e.g. `"10MB"`) falls back to the
+        # 10 MiB default instead of raising `ArgumentError`
+        # and crashing the entire `sync` run before any repo
+        # work.
+        #
+        # Accepted: any positive integer in base 10
+        # (e.g. `"1048576"`, `"  524288  "`). Falls back to
+        # `DEFAULT_LOG_MAX_BYTES` (and emits a single
+        # `Kernel#warn` to stderr) for: unset, empty,
+        # whitespace, non-numeric (`"10MB"`, `"abc"`), zero,
+        # and negative inputs. Never raises.
+        #
+        # The optional `env_value` arg exists so the unit
+        # tests can pass arbitrary values without mutating
+        # the real `ENV`; production callers invoke with
+        # no args and the method reads `ENV` itself.
+        def log_max_bytes(env_value = ENV["REPO_TENDER_LOG_MAX_BYTES"])
+          return DEFAULT_LOG_MAX_BYTES if env_value.nil? || env_value.strip.empty?
+
+          parsed = Integer(env_value, 10, exception: false)
+          return parsed if parsed.is_a?(Integer) && parsed.positive?
+
+          warn "repo-tender: REPO_TENDER_LOG_MAX_BYTES=#{env_value.inspect} is invalid; " \
+            "falling back to #{DEFAULT_LOG_MAX_BYTES} bytes"
+          DEFAULT_LOG_MAX_BYTES
+        end
+      end
+    end
+  end
+end
+
+SpaceArchitect::Pristine::CLI::Registry.register "sync", SpaceArchitect::Pristine::CLI::Sync::Run