space-architect 1.1.0

data/vendor/repo-tender/lib/space_architect/pristine/ui/interactive_reporter.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-cursor"
+
+module SpaceArchitect::Pristine
+  module UI
+    # Compact, single-line live progress renderer for `sync`.
+    # Driven by one render-loop fiber spawned as a child of the engine task
+    # via `attach(task)` — NO Ruby Thread.
+    #
+    # Two phases under one attach/detach (GS6):
+    #
+    #   Phase 1 — Listing: fires between listing_started and listing_finished.
+    #     Live status line shows "listing N orgs… ✓ K done". As each org
+    #     completes, a persistent line is emitted (org name + count).
+    #
+    #   Phase 2 — Sweep: fires after run_started through run_finished.
+    #     Reverts to the compact repo counter (synced X/N + tallies).
+    #
+    # Output model:
+    #   - One live status line, rewritten in place via \r + \e[K.
+    #   - Persistent scrollback lines for listing phase (one per org) and
+    #     for NON-CLEAN repos only in sweep phase.
+    #   - Total output: O(orgs + non_clean + failed + constant).
+    #
+    # Invariants:
+    #   - The render fiber is the sole writer to `out`; worker fibers only
+    #     mutate tally/queue state via the reporter event methods.
+    #   - `Kernel#sleep` inside the render fiber yields to the reactor
+    #     (cooperative scheduling). Never Thread.new.
+    #   - On `^C`, the scheduler cancels the child render fiber; its `ensure`
+    #     block restores the cursor unconditionally.
+    class InteractiveReporter
+      FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+      ADDED_LIST_THRESHOLD = 10
+      IN_FLIGHT_MAX_WIDTH = 40
+
+      def initialize(out, mode:, cadence: 0.1)
+        @out = out
+        @pastel = Pastel.new(enabled: mode.color)
+        @cadence = cadence
+
+        # Listing phase state
+        @org_total = 0
+        @org_done = 0
+        @pending_org_lines = []
+
+        # Sweep phase state
+        @total = 0
+        @finished = 0
+        @clean_count = 0
+        @nonclean_count = 0
+        @failed_count = 0
+        @pending_lines = []
+
+        # In-flight tracking (insertion-ordered: last entry = most-recently-started)
+        @in_flight = {}
+
+        # End-of-run breakdown state
+        @action_counts = Hash.new(0)
+        @total_commits = 0
+        @added_repos = []
+
+        @frame_idx = 0
+        @phase = :listing  # :listing | :sweep
+        @done = false
+        @render_task = nil
+      end
+
+      def attach(task)
+        @render_task = task.async { render_loop }
+      end
+
+      def detach
+        @done = true
+        @render_task&.wait
+        @render_task = nil
+      end
+
+      # --- Listing phase events ---
+
+      def listing_started(total:)
+        @org_total = total
+        @phase = :listing
+      end
+
+      def org_listed(ref, count:)
+        @org_done += 1
+        @pending_org_lines << if count
+          "#{@pastel.green("✓")} #{ref.name}  #{count} repo(s)"
+        else
+          "#{@pastel.red("✗")} #{ref.name}  FAILED"
+        end
+      end
+
+      def listing_finished
+        # Phase transition handled by run_started
+      end
+
+      # --- Sweep phase events ---
+
+      def run_started(total:)
+        @total = total
+        @phase = :sweep
+      end
+
+      def repo_started(ref)
+        @in_flight[ref] = "checking"
+      end
+
+      def repo_phase(ref, phase)
+        return unless @in_flight.key?(ref)
+        @in_flight[ref] = case phase
+        when :cloning then "cloning"
+        when :fast_forwarding then "fast-forwarding"
+        when :switching then "switching"
+        else @in_flight[ref]
+        end
+      end
+
+      def repo_finished(ref, status, action:, commits: 0)
+        @in_flight.delete(ref)
+        @finished += 1
+        @action_counts[action] += 1
+        @total_commits += commits
+        @added_repos << ref if action == :cloned
+        if status.to_s == "clean"
+          @clean_count += 1
+        else
+          @nonclean_count += 1
+          @pending_lines << "#{@pastel.yellow("⚠")} #{ref}  #{status}"
+        end
+      end
+
+      def repo_failed(ref, error)
+        @in_flight.delete(ref)
+        @finished += 1
+        @failed_count += 1
+        @action_counts[:error] += 1
+        @pending_lines << "#{@pastel.red("✗")} #{ref}  #{error}"
+      end
+
+      def run_finished(summary) = nil
+
+      private
+
+      def render_loop
+        @out.write(TTY::Cursor.hide)
+        @out.flush
+
+        loop do
+          render_tick
+          @frame_idx += 1
+          break if @done
+          sleep @cadence
+        end
+      ensure
+        # Flush any remaining org lines (listing phase may have ended without
+        # a final tick draining them).
+        pending_org = @pending_org_lines.slice!(0, @pending_org_lines.length)
+        pending = @pending_lines.slice!(0, @pending_lines.length)
+        @out.write("\r\e[K")
+        pending_org.each { |line| @out.write("#{line}\n") }
+        pending.each { |line| @out.write("#{line}\n") }
+        @out.write("#{build_summary_line}\n")
+        breakdown = build_breakdown_line
+        @out.write("#{breakdown}\n") unless breakdown.empty?
+        added = build_added_repos_block
+        @out.write(added) unless added.empty?
+        @out.write(TTY::Cursor.show)
+        @out.flush
+      end
+
+      def render_tick
+        if @phase == :listing
+          render_listing_tick
+        else
+          render_sweep_tick
+        end
+      end
+
+      def render_listing_tick
+        pending = @pending_org_lines.slice!(0, @pending_org_lines.length)
+        if pending.any?
+          @out.write("\r\e[K")
+          pending.each { |line| @out.write("#{line}\n") }
+        end
+        frame = @pastel.cyan(FRAMES[@frame_idx % FRAMES.length])
+        @out.write("\r\e[K#{frame} listing #{@org_total} org(s)…  #{@pastel.green("✓")} #{@org_done} done")
+      end
+
+      def render_sweep_tick
+        org_pending = @pending_org_lines.slice!(0, @pending_org_lines.length)
+        if org_pending.any?
+          @out.write("\r\e[K")
+          org_pending.each { |line| @out.write("#{line}\n") }
+        end
+        pending = @pending_lines.slice!(0, @pending_lines.length)
+        if pending.any?
+          @out.write("\r\e[K")
+          pending.each { |line| @out.write("#{line}\n") }
+        end
+        @out.write("\r\e[K#{build_status_line}")
+      end
+
+      def build_status_line
+        frame = @pastel.cyan(FRAMES[@frame_idx % FRAMES.length])
+        # Right-justify every counter to the digit-width of @total (the cap on
+        # all of them) so the in-flight suffix sits at a fixed column instead of
+        # drifting right as counts cross digit boundaries. Padding is invisible
+        # leading spaces.
+        w = @total.to_s.length
+        base = "#{frame} synced #{@finished.to_s.rjust(w)}/#{@total}   #{@pastel.green("✓")} #{@clean_count.to_s.rjust(w)}   #{@pastel.yellow("⚠")} #{@nonclean_count.to_s.rjust(w)}   #{@pastel.red("✗")} #{@failed_count.to_s.rjust(w)}"
+        "#{base}#{build_in_flight_suffix}"
+      end
+
+      def build_summary_line
+        "synced #{@finished}/#{@total}   #{@pastel.green("✓")} #{@clean_count} clean   #{@pastel.yellow("⚠")} #{@nonclean_count} non-clean   #{@pastel.red("✗")} #{@failed_count} failed"
+      end
+
+      def build_in_flight_suffix
+        return "" if @in_flight.empty?
+        ref, verb = @in_flight.to_a.last
+        short = ref.to_s.split("/", 2).last.to_s
+        short = short[0, IN_FLIGHT_MAX_WIDTH]
+        "   · #{verb} #{short}"
+      end
+
+      def build_breakdown_line
+        parts = []
+        if (n = @action_counts[:cloned]) > 0
+          parts << "cloned #{n}"
+        end
+        if (n = @action_counts[:fast_forwarded]) > 0
+          commit_str = (@total_commits > 0) ? " (#{@total_commits} commit#{"s" unless @total_commits == 1})" : ""
+          parts << "fast-forwarded #{n}#{commit_str}"
+        end
+        if (n = @action_counts[:up_to_date]) > 0
+          parts << "up-to-date #{n}"
+        end
+        if (n = @action_counts[:switched]) > 0
+          parts << "switched #{n}"
+        end
+        if (n = @action_counts[:dirty]) > 0
+          parts << "dirty #{n}"
+        end
+        if (n = @action_counts[:diverged]) > 0
+          parts << "diverged #{n}"
+        end
+        if (n = @action_counts[:wrong_branch]) > 0
+          parts << "wrong-branch #{n}"
+        end
+        if (n = @action_counts[:detached]) > 0
+          parts << "detached #{n}"
+        end
+        error_n = @action_counts[:error]
+        if error_n > 0
+          parts << "#{(error_n == 1) ? "error" : "errors"} #{error_n}"
+        end
+        parts.join("   ")
+      end
+
+      def build_added_repos_block
+        return "" if @added_repos.empty?
+        count = @added_repos.size
+        if count > ADDED_LIST_THRESHOLD
+          "added #{count} repos\n"
+        else
+          lines = ["added #{count} #{(count == 1) ? "repo" : "repos"}:"]
+          @added_repos.each do |ref|
+            short = ref.to_s.split("/", 2).last.to_s
+            lines << "  #{short}"
+          end
+          lines.join("\n") + "\n"
+        end
+      end
+    end
+  end
+end

data/vendor/repo-tender/lib/space_architect/pristine/ui/json_reporter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module SpaceArchitect::Pristine
+  module UI
+    # Emits one JSON object per event line (12-factor style) to `out`.
+    # Every object carries at minimum: "event", "t" (ISO8601 timestamp),
+    # plus event-specific keys (ref, status, error, total, summary).
+    # @out.sync = true ensures output is immediate on non-TTY pipes (GS5).
+    class JsonReporter
+      def initialize(out)
+        @out = out
+        @out.sync = true
+      end
+
+      def attach(task) = nil
+      def detach = nil
+
+      def listing_started(total:) = emit(event: "listing_started", total: total)
+      def org_listed(ref, count:) = emit(event: "org_listed", org: ref.name, count: count)
+      def listing_finished = emit(event: "listing_finished")
+
+      def run_started(total:) = emit(event: "run_started", total: total)
+      def repo_started(ref) = emit(event: "repo_started", ref: ref)
+      def repo_phase(ref, phase) = emit(event: "repo_phase", ref: ref, phase: phase)
+      def repo_finished(ref, status, action:, commits: 0) = emit(event: "repo_finished", ref: ref, status: status, action: action, commits: commits)
+      def repo_failed(ref, error) = emit(event: "repo_failed", ref: ref, error: error.to_s)
+      def run_finished(summary) = emit(event: "run_finished", summary: summary)
+
+      private
+
+      def emit(payload)
+        @out.puts JSON.generate(payload.merge(t: Time.now.iso8601))
+      end
+    end
+  end
+end

data/vendor/repo-tender/lib/space_architect/pristine/ui/mode.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "dry/struct"
+require "dry/types"
+
+module SpaceArchitect::Pristine
+  module UI
+    Types = Dry.Types()
+
+    # Resolved output mode — immutable dry-struct constructed once per command
+    # invocation from (flags, env, out.tty?) using precedence: flag > env > autodetect.
+    #
+    # Frozen contract (PRD §3.1):
+    #
+    #   format:  :pretty | :plain | :json
+    #   color:   true | false
+    #   animate: true | false  (always false in Slice A; Slice B gates on this)
+    #   quiet:   true | false
+    #
+    # Color precedence: --no-color (flag) > CLICOLOR_FORCE (env-force) >
+    #   NO_COLOR/TERM=dumb/non-:pretty/non-TTY (env+autodetect).
+    class Mode < Dry::Struct
+      FORMATS = %i[pretty plain json].freeze
+
+      attribute :color, Types::Bool
+      attribute :animate, Types::Bool
+      attribute :quiet, Types::Bool
+      attribute :format, Types::Symbol.constrained(included_in: FORMATS)
+
+      # @param flags [Hash] CLI flags: :plain, :json, :no_color, :quiet (truthy = set)
+      # @param env   [Hash] environment hash (use CLI.env for the injectable test seam)
+      # @param out   [IO]  the output stream; tested with out.tty?
+      def self.resolve(flags:, env:, out:)
+        json = !!flags[:json]
+        plain = !!flags[:plain]
+        no_color = !!flags[:no_color]
+        quiet = !!flags[:quiet]
+
+        format = if json
+          :json
+        elsif plain || !out.tty?
+          :plain
+        else
+          :pretty
+        end
+
+        no_color_env = env["NO_COLOR"] && !env["NO_COLOR"].empty?
+        clicolor_force = env["CLICOLOR_FORCE"] && !env["CLICOLOR_FORCE"].empty?
+        term_dumb = env["TERM"] == "dumb"
+
+        color = if no_color
+          false
+        elsif clicolor_force
+          true
+        elsif no_color_env || term_dumb || format != :pretty || !out.tty?
+          false
+        else
+          true
+        end
+
+        ci = env["CI"] && !env["CI"].empty?
+        animate = format == :pretty && out.tty? && !quiet && !ci
+
+        new(color: color, animate: animate, quiet: quiet, format: format)
+      end
+    end
+  end
+end

data/vendor/repo-tender/lib/space_architect/pristine/ui/plain_reporter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SpaceArchitect::Pristine
+  module UI
+    # Emits one tab-separated line per terminal repo event, ANSI-free always.
+    # repo_finished → "ref\tstatus"; repo_failed → "ref\tFAILED\terror".
+    # org_listed → "listed: ref.name\tN repos" (or "listed: ref.name\tFAILED" on failure).
+    # Both write to the same `out` stream (G4 choice: no separate stderr stream
+    # in Slice A; FAILED marker distinguishes errors).
+    # @out.sync = true ensures output is immediate on non-TTY pipes (GS5).
+    class PlainReporter
+      def initialize(out, mode: nil)
+        @out = out
+        @out.sync = true
+      end
+
+      def attach(task) = nil
+      def detach = nil
+
+      def listing_started(total:)
+        @out.puts "listing: #{total} org(s)"
+      end
+
+      def org_listed(ref, count:)
+        if count
+          @out.puts "listed: #{ref.name}\t#{count} repo(s)"
+        else
+          @out.puts "listed: #{ref.name}\tFAILED"
+        end
+      end
+
+      def listing_finished = nil
+
+      def run_started(total:)
+        @out.puts "starting: #{total} repo(s)"
+      end
+
+      def repo_started(ref) = nil
+
+      def repo_phase(ref, phase) = nil
+
+      def repo_finished(ref, status, action:, commits: 0)
+        @out.puts "#{ref}\t#{status}"
+      end
+
+      def repo_failed(ref, error)
+        @out.puts "#{ref}\tFAILED\t#{error}"
+      end
+
+      def run_finished(summary) = nil
+    end
+  end
+end

data/vendor/repo-tender/lib/space_architect/pristine/ui/reporter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SpaceArchitect::Pristine
+  module UI
+    # The reporter event interface. Every implementation must respond to:
+    #
+    #   attach(task)                # spawn render-loop fiber as child of task
+    #                               # called BEFORE listing begins; no total yet
+    #   listing_started(total:)     # N orgs about to be listed
+    #   org_listed(ref, count:)     # one per org as it finishes listing;
+    #                               #   ref is OrgRef; count: nil on failure
+    #   listing_finished            # all orgs listed (or skipped on auth failure)
+    #   run_started(total:)         # N repos about to be processed
+    #   repo_started(ref)           # work begins on ref ("host/owner/name" string)
+    #   repo_phase(ref, phase)      # :cloning | :fast_forwarding | :switching
+    #   repo_finished(ref, status, action:, commits: 0)
+    #                               # final status string (matches state row);
+    #                               # action: realized-action Symbol; commits: Integer
+    #   repo_failed(ref, error)     # failure string (plan error or unhandled raise)
+    #   run_finished(summary)       # Hash<String,Integer> status→count
+    #   detach                      # stop render fiber, restore terminal
+    #
+    # Engine event sequence:
+    #   attach(task) → listing_started(total:) → {org_listed(ref, count:)} →
+    #   listing_finished → run_started(total:) → {repo_started → repo_phase* →
+    #   repo_finished|repo_failed} → run_finished(summary) → detach
+    #
+    # Implementations:
+    #   NullReporter         — all no-ops; the engine default
+    #   PlainReporter        — one ANSI-free line per terminal event
+    #   JsonReporter         — one JSON object per event line (12-factor)
+    #   InteractiveReporter  — color + animated progress (two-phase: listing + sweep)
+
+    class NullReporter
+      def attach(task) = nil
+      def listing_started(total:) = nil
+      def org_listed(ref, count:) = nil
+      def listing_finished = nil
+      def run_started(total:) = nil
+      def repo_started(ref) = nil
+      def repo_phase(ref, phase) = nil
+      def repo_finished(ref, status, action:, commits: 0) = nil
+      def repo_failed(ref, error) = nil
+      def run_finished(summary) = nil
+      def detach = nil
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SpaceArchitect
+  module Pristine
+    VERSION = "0.1.0"
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "space_architect/pristine/version"
+
+# repo-tender — keep local git clones evergreen.
+# (clean · on the remote's default branch · fetched within refresh_interval)
+#
+# Slice 1 surface: Paths, Shell, Config::{Model,Contract,Store},
+# State::Store, SCM::{Client,Git,Status}, Forge::{Client,GitHub}.
+# Later slices build sync orchestration, CLI, and launchd on top.
+
+module SpaceArchitect::Pristine
+end
+
+require "space_architect/pristine/paths"
+require "space_architect/pristine/shell"
+require "space_architect/pristine/config/model"
+require "space_architect/pristine/config/contract"
+require "space_architect/pristine/config/store"
+require "space_architect/pristine/state/store"
+require "space_architect/pristine/state/lock"
+require "space_architect/pristine/scm/client"
+require "space_architect/pristine/scm/status"
+require "space_architect/pristine/scm/git"
+require "space_architect/pristine/forge/client"
+require "space_architect/pristine/forge/github"
+require "space_architect/pristine/sync/repo_plan"
+require "space_architect/pristine/sync/engine"
+require "space_architect/pristine/config/duration"
+require "space_architect/pristine/log_rotator"
+require "space_architect/pristine/launchd/plist"
+require "space_architect/pristine/launchd/agent"
+require "space_architect/pristine/ui/reporter"
+require "space_architect/pristine/ui/mode"
+require "space_architect/pristine/ui/plain_reporter"
+require "space_architect/pristine/ui/json_reporter"
+require "space_architect/pristine/cli"