space-architect 8.0.0 → 9.0.0

data/lib/space_src/sync/repo_plan.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require "dry/monads"
-require "space_src/scm/client"
-require "space_src/scm/status"
-
-module Space::Src
-  module Sync
-    # Pure-ish evergreen evaluation. Given a RepoRef + on-disk path +
-    # SCM client + refresh_interval, observe the repo and decide an
-    # action. Returns a Plan (Data) carrying {action, status, reason}.
-    #
-    # Per Slice 2 PRD §3.3 + gate G2 seam, the plan is the *decision*
-    # half; the engine is the *execution* half. The plan only uses
-    # read-side SCM methods (`status`, `current_branch`,
-    # `default_branch`, `last_fetch_at`) plus `fetch` when not-fresh
-    # (a network observation). It never mutates branches.
-    #
-    # Action ↔ status mapping (per Slice 2 gates):
-    #
-    #   :clone               → status "missing" (before action) / "clean" (after)
-    #   :fast_forward        → status "clean" (after)
-    #   :switch              → status "clean" (after; the source status was wrong_branch/detached)
-    #   :skip_fresh          → status "clean"
-    #   :up_to_date          → status "clean"
-    #   :sync_empty          → status "clean" (empty clone of empty/unborn remote)
-    #   :report_dirty        → status "dirty"
-    #   :report_diverged     → status "diverged"
-    #   :report_wrong_branch → status "wrong_branch"
-    #   :report_detached     → status "detached"
-    #   :report_error        → status "error" (probe Failure translation; not in the spec's
-    #                                            nine actions but required by G8)
-    #
-    # The plan always returns Success(Plan). Any SCM-probe Failure is
-    # translated to a :report_error action so the engine has a uniform
-    # dispatch surface. The plan never raises.
-    module RepoPlan
-      extend Dry::Monads[:result]
-
-      Plan = Data.define(:action, :status, :reason) do
-        def initialize(action:, status:, reason: nil)
-          super
-        end
-      end
-
-      def self.call(repo_ref:, path:, scm:, refresh_interval:, now: Time.now)
-        # 1. Present? (PRD §3.3 step 1; gate G6)
-        unless Dir.exist?(path)
-          return Success(Plan.new(
-            action: :clone,
-            status: "missing",
-            reason: "path does not exist: #{path}"
-          ))
-        end
-
-        # 2. Working-tree status (porcelain v2 with branch.ab).
-        #    This single call gives us clean/dirty + the ahead/behind
-        #    numbers we need for the behind check (disagreement #2:
-        #    we use SCM::Status#behind / #ahead, not a new SCM
-        #    boundary, since the BOUNDARIES list only permits adding
-        #    `switch` to SCM::Client).
-        status_result = scm.status(path)
-        if status_result.failure?
-          return report_error(repo_ref, "status probe failed: #{status_result.failure.inspect}")
-        end
-        scm_status = status_result.success
-
-        # 2b. Unborn (empty) repo? No commits exist anywhere on the
-        #     local clone. Skip the `current_branch` / `default_branch`
-        #     probes — both would succeed but `default_branch` calls
-        #     `git remote set-head origin -a` which exits non-zero on an
-        #     empty remote ("Cannot determine remote HEAD"), turning a
-        #     valid empty clone into a false :report_error. Delegate the
-        #     remote-has-commits? check to the engine's sync_empty call.
-        if scm_status.unborn?
-          if scm_status.clean?
-            return Success(Plan.new(
-              action: :sync_empty,
-              status: "clean",
-              reason: "empty repository (no commits yet)"
-            ))
-          else
-            return Success(Plan.new(
-              action: :report_dirty,
-              status: "dirty",
-              reason: "empty repository with uncommitted local files; not touching"
-            ))
-          end
-        end
-
-        # 3. Current branch + default branch.
-        current_result = scm.current_branch(path)
-        if current_result.failure?
-          return report_error(repo_ref, "current_branch probe failed: #{current_result.failure.inspect}")
-        end
-        current = current_result.success
-
-        default_result = scm.default_branch(path)
-        if default_result.failure?
-          return report_error(repo_ref, "default_branch probe failed: #{default_result.failure.inspect}")
-        end
-        default_branch = default_result.success
-
-        # 4. Detached or wrong branch? (gate G5)
-        if current.nil?
-          if scm_status.clean?
-            return Success(Plan.new(
-              action: :switch,
-              status: "detached",
-              reason: "detached HEAD on a clean tree; switching to #{default_branch}"
-            ))
-          else
-            return Success(Plan.new(
-              action: :report_detached,
-              status: "detached",
-              reason: "detached HEAD with a dirty tree; not switching"
-            ))
-          end
-        elsif current != default_branch
-          if scm_status.clean?
-            return Success(Plan.new(
-              action: :switch,
-              status: "wrong_branch",
-              reason: "on branch #{current} (default is #{default_branch}); switching"
-            ))
-          else
-            return Success(Plan.new(
-              action: :report_wrong_branch,
-              status: "wrong_branch",
-              reason: "on branch #{current} (default is #{default_branch}) with a dirty tree; not switching"
-            ))
-          end
-        end
-
-        # 5. Clean? (gate G3 — dirty repos are NEVER touched)
-        unless scm_status.clean?
-          return Success(Plan.new(
-            action: :report_dirty,
-            status: "dirty",
-            reason: "working tree has changes (#{scm_status.entries.length} entry/entries)"
-          ))
-        end
-
-        # 6. Fresh? (PRD §3.3 step 4; gate G2; PHASE-0 ruling: nil /
-        #    stale / Failure all → stale; never skip on unreadable/
-        #    absent FETCH_HEAD)
-        last_fetch = scm.last_fetch_at(path)
-        if last_fetch.success?
-          t = last_fetch.success
-          if t && (now - t) <= refresh_interval
-            return Success(Plan.new(
-              action: :skip_fresh,
-              status: "clean",
-              reason: "fetched at #{t.iso8601} within refresh_interval=#{refresh_interval}s"
-            ))
-          end
-        end
-
-        # 7. Not fresh → fetch + re-check status for behind / diverged /
-        #    up_to_date. After fetch, `origin/<default>` is up to date
-        #    with the remote, so the next `scm.status` call's
-        #    `behind`/`ahead` (porcelain v2 `# branch.ab`) are current.
-        fetch_result = scm.fetch(path)
-        if fetch_result.failure?
-          return report_error(repo_ref, "fetch failed: #{fetch_result.failure.inspect}")
-        end
-
-        re_status = scm.status(path)
-        if re_status.failure?
-          return report_error(repo_ref, "status re-probe after fetch failed: #{re_status.failure.inspect}")
-        end
-        behind = re_status.success.behind
-        ahead = re_status.success.ahead
-
-        # 8. Diverged? (gate G4 — never reset, never auto-resolve)
-        if ahead > 0
-          return Success(Plan.new(
-            action: :report_diverged,
-            status: "diverged",
-            reason: "local is #{ahead} commit(s) ahead of origin/#{default_branch} (no reset --hard)"
-          ))
-        end
-
-        # 9. Behind? (gate G1)
-        if behind > 0
-          return Success(Plan.new(
-            action: :fast_forward,
-            status: "clean",
-            reason: "behind by #{behind} commit(s); merging --ff-only"
-          ))
-        end
-
-        # 10. Up to date (no-op — just a state write at the engine layer)
-        Success(Plan.new(
-          action: :up_to_date,
-          status: "clean",
-          reason: "up to date with origin/#{default_branch}"
-        ))
-      end
-
-      def self.report_error(repo_ref, reason)
-        Success(Plan.new(
-          action: :report_error,
-          status: "error",
-          reason: "#{repo_key(repo_ref)}: #{reason}"
-        ))
-      end
-
-      def self.repo_key(r)
-        "#{r.host}/#{r.owner}/#{r.name}"
-      end
-    end
-  end
-end

data/lib/space_src/sync/report.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Space::Src
-  module Sync
-    # What one sync pass did.
-    #
-    # `state` is the merged whole-state that gets written to disk: it
-    # carries a row for every repo ever synced, because build_new_state
-    # starts from the previous state and merges this run's outcomes into
-    # it. `processed` counts only the repos this run actually touched.
-    #
-    # The two diverge whenever the run is scoped (`sync --repo`) or the
-    # state file already holds rows from earlier runs — which is why
-    # callers wanting "how many repos did this run handle?" must read
-    # `processed` and never `state.repos.size`.
-    Report = Data.define(:state, :processed)
-  end
-end

data/lib/space_src/ui/interactive_reporter.rb

@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-
-require "pastel"
-require "tty-cursor"
-
-module Space::Src
-  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/lib/space_src/ui/json_reporter.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "time"
-
-module Space::Src
-  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/lib/space_src/ui/mode.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/struct"
-require "dry/types"
-
-module Space::Src
-  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/lib/space_src/ui/plain_reporter.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Space::Src
-  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