space-architect 8.0.0 → 9.1.0

data/lib/space_src/cli/repo.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require "pastel"
-require "dry/monads"
-require "space_src/ui/mode"
-require "space_src/cli/options"
-
-module Space::Src
-  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
-          Space::Src::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".
-Space::Src::CLI::Registry.register "repo" do |prefix|
-  prefix.register "add", Space::Src::CLI::Repo::Add
-  prefix.register "remove", Space::Src::CLI::Repo::Remove
-  prefix.register "list", Space::Src::CLI::Repo::List
-end

data/lib/space_src/cli/shell.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require "space_src/shell_integration"
-
-module Space::Src
-  module CLI
-    module Shell
-      class Init < Dry::CLI::Command
-        desc "Print shell integration script"
-        argument :shell_name, required: true, desc: "Shell name (e.g. fish)"
-
-        def call(shell_name:, **)
-          out.puts ShellIntegration.for(shell_name)
-          CLI.record_outcome(Outcome.new(exit_code: 0))
-        rescue => e
-          err.puts "src shell init: #{e.message}"
-          CLI.record_outcome(Outcome.new(exit_code: 1))
-        end
-      end
-
-      class Fish < Dry::CLI::Command
-        desc "Manage fish shell integration: install, uninstall, path"
-        argument :subcommand, required: false, desc: "install, uninstall, or path (default: install)"
-        option :force, type: :boolean, default: false, desc: "Overwrite or remove existing shell files"
-
-        def call(subcommand: "install", force: false, **)
-          case subcommand
-          when "install"
-            result = ShellIntegration.install("fish", env: CLI.env, force: force)
-            out.puts fish_install_message(result.fetch(:action), result.fetch(:path))
-            out.puts fish_completions_install_message(result.fetch(:completions_action), result.fetch(:completions_path))
-            out.puts "Restart fish to load the integration in this terminal: exec fish"
-            CLI.record_outcome(Outcome.new(exit_code: 0))
-          when "uninstall"
-            result = ShellIntegration.uninstall("fish", env: CLI.env, force: force)
-            out.puts fish_uninstall_message(result.fetch(:action), result.fetch(:path))
-            out.puts fish_completions_uninstall_message(result.fetch(:completions_action), result.fetch(:completions_path))
-            CLI.record_outcome(Outcome.new(exit_code: 0))
-          when "path"
-            out.puts "Function:    #{ShellIntegration.path_for("fish", env: CLI.env)}"
-            out.puts "Completions: #{ShellIntegration.completions_path_for("fish", env: CLI.env)}"
-            CLI.record_outcome(Outcome.new(exit_code: 0))
-          else
-            err.puts "Usage: src shell fish [install|uninstall|path]"
-            CLI.record_outcome(Outcome.new(exit_code: 1))
-          end
-        rescue => e
-          err.puts "src shell fish: #{e.message}"
-          CLI.record_outcome(Outcome.new(exit_code: 1))
-        end
-
-        private
-
-        def fish_install_message(action, path)
-          case action
-          when :unchanged then "Fish integration already installed: #{path}"
-          when :updated   then "Updated fish integration: #{path}"
-          else                 "Installed fish integration: #{path}"
-          end
-        end
-
-        def fish_uninstall_message(action, path)
-          case action
-          when :missing then "Fish integration was not installed: #{path}"
-          else               "Removed fish integration: #{path}"
-          end
-        end
-
-        def fish_completions_install_message(action, path)
-          case action
-          when :unchanged then "Fish completions already installed: #{path}"
-          when :updated   then "Updated fish completions: #{path}"
-          else                 "Installed fish completions: #{path}"
-          end
-        end
-
-        def fish_completions_uninstall_message(action, path)
-          case action
-          when :missing then "Fish completions were not installed: #{path}"
-          else               "Removed fish completions: #{path}"
-          end
-        end
-      end
-
-      class Complete < Dry::CLI::Command
-        desc "Print completion candidates"
-        argument :kind, required: true, desc: "Completion kind"
-        argument :extra, type: :array, required: false, desc: "Extra args for completion"
-
-        def call(kind:, extra: [], **)
-          case kind
-          when "checkouts"
-            begin
-              paths = CLI.make_paths
-              config = Config::Store.load(paths.config_file).success
-              Nav.scan(config.base_dir).each { |e| out.puts e[:target] }
-            rescue
-              # Never raise on a completion call — missing/unparseable config is fine.
-            end
-            CLI.record_outcome(Outcome.new(exit_code: 0))
-          when "shells"
-            out.puts "fish"
-            CLI.record_outcome(Outcome.new(exit_code: 0))
-          else
-            err.puts "Usage: src shell complete checkouts|shells"
-            CLI.record_outcome(Outcome.new(exit_code: 1))
-          end
-        rescue => e
-          err.puts "src shell complete: #{e.message}"
-          CLI.record_outcome(Outcome.new(exit_code: 1))
-        end
-      end
-    end
-  end
-end
-
-Space::Src::CLI::Registry.register "shell" do |prefix|
-  prefix.register "init",      Space::Src::CLI::Shell::Init
-  prefix.register "fish",      Space::Src::CLI::Shell::Fish
-  prefix.register "complete",  Space::Src::CLI::Shell::Complete
-end

data/lib/space_src/cli/status.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require "pastel"
-require "space_src/ui/mode"
-require "space_src/cli/options"
-
-module Space::Src
-  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/space-src/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 `src 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
-
-Space::Src::CLI::Registry.register "status", Space::Src::CLI::Status::Show

data/lib/space_src/cli/sync.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/monads"
-require "space_src/cli/repo"  # for Repo::Helpers.parse_ref
-require "space_src/cli/options"
-require "space_src/ui/mode"
-require "space_src/ui/plain_reporter"
-require "space_src/ui/json_reporter"
-require "space_src/ui/interactive_reporter"
-
-module Space::Src
-  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)
-
-          # Resolved BEFORE the scoping block: the "scoping sync to:"
-          # notice below is prose, and must be suppressed in JSON mode
-          # for the same reason the summary line is. Resolution depends
-          # only on flags/env/out, so it is safe this early.
-          mode = UI::Mode.resolve(
-            flags: {plain: plain, json: json, no_color: no_color, quiet: quiet},
-            env: CLI.env,
-            out: out
-          )
-          # Every line of --json output must parse as one JSON object.
-          human = mode.format != :json
-
-          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)}" if human
-          end
-
-          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
-
-          # prune only on a full sweep. With --repo the config above was
-          # narrowed to one repo, so pruning would delete the state rows
-          # for every OTHER tracked repo.
-          result = Space::Src::Sync::Engine.new(reporter: reporter)
-            .call(config: config, paths: paths, prune: repo.nil?)
-          if result.failure?
-            return fail_with(self, "sync failed: #{format_failure(result.failure)}")
-          end
-
-          report = result.success
-          # JsonReporter already emits a run_finished event carrying the
-          # summary, so suppressing the prose line loses nothing.
-          out.puts "synced #{report.processed} repo(s)" if human
-          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
-          Space::Src::CLI.record_outcome(Outcome.new(exit_code: 1, message: msg))
-        end
-
-        # Default log-rotation threshold: 10 MiB. Tunable via the
-        # env var `SPACE_SRC_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|
-            Space::Src::LogRotator.call(p, threshold_bytes: threshold)
-          end
-        end
-
-        # CF6 (Slice 5): defensively parse the
-        # `SPACE_SRC_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["SPACE_SRC_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 "src: SPACE_SRC_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
-
-Space::Src::CLI::Registry.register "sync", Space::Src::CLI::Sync::Run

data/lib/space_src/cli.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/cli"
-require "space_src/migration"
-
-module Space::Src
-  # CLI surface — thin translation layer between argv and the
-  # existing Config::Store / State::Store / Sync::Engine boundaries.
-  #
-  # The CLI never mutates a git repo directly; repo mutation happens
-  # inside the engine, which already upholds the no-data-loss
-  # invariant (PRD §1). The CLI's job is:
-  #   1. parse argv (via Dry::CLI's nested `register`)
-  #   2. load/mutate validated config (Config::Store) OR delegate to
-  #      the engine / state store
-  #   3. translate Result to: out/err message + exit code
-  #
-  # Exit-code seam: each command records an `Outcome(exit_code:,
-  # message:)` (the thread-local stash) and writes the user-facing
-  # message to `out`/`err` via the injected IOs. The `exe/src`
-  # entrypoint reads the recorded Outcome and calls Kernel.exit with
-  # the code — see CLI.run below. Tests can inspect last_outcome
-  # in-process (no subprocess needed for unit tests); a subprocess
-  # Open3.capture3 covers the G3 "real exit" proof.
-  module CLI
-    # The Outcome value object. `exit_code` is 0 for success and 1
-    # for Failure-derived failures. `message` is the user-facing
-    # explanation already written to err (kept here so the
-    # entrypoint could log/record it in a future slice).
-    Outcome = Data.define(:exit_code, :message) do
-      def initialize(exit_code:, message: nil)
-        super
-      end
-    end
-
-    # Thread-local env hash. Defaults to ENV. Tests inject a temp
-    # HOME / XDG_* hash via Thread.current[:space_src_cli_env] =
-    # env_hash. The CLI's `make_paths` reads this to resolve the
-    # config/state file locations under the test's temp home.
-    def self.env
-      Thread.current[:space_src_cli_env] || ENV
-    end
-
-    # Thread-local Outcome stash. The most recent command's Outcome
-    # is read by CLI.run to set the process exit code.
-    def self.record_outcome(outcome)
-      Thread.current[:space_src_cli_outcome] = outcome
-    end
-
-    def self.last_outcome
-      Thread.current[:space_src_cli_outcome]
-    end
-
-    # Program-name-level invocations that must succeed (exit 0) with
-    # output on stdout. Dry::CLI has no root command registered, so it
-    # would otherwise route these through its "command not found" path
-    # (Usage → stderr → exit 1). We intercept ONLY the exact top-level
-    # forms here; a *leaf* help like `sync --help` (argv ["sync",
-    # "--help"]) and a *group* like `repo` / `repo --help` are NOT
-    # matched, so Dry::CLI keeps handling them as before (leaf help →
-    # stdout/exit 0; group → usage/stderr/exit 1, accepted per G7).
-    TOP_LEVEL_HELP = [[], ["--help"], ["-h"], ["help"]].freeze
-    VERSION_REQUEST = [["version"], ["--version"]].freeze
-
-    # True when argv is a single token that is not a registered top-level
-    # command or group, and not already handled by the help/version intercepts.
-    # Both CLI.run and dispatch_src delegate to this shared predicate so the
-    # routing logic is defined exactly once.
-    def self.bare_query?(argv)
-      return false if TOP_LEVEL_HELP.include?(argv)
-      return false if VERSION_REQUEST.include?(argv)
-      # paths:exempt - Registry.get([]).children is a dry-cli command-tree node, not a filesystem path
-      argv.length == 1 && !Registry.get([]).children.key?(argv[0])
-    end
-
-    # Entrypoint. Called by exe/src. Intercepts the top-level
-    # help/version forms (stdout, exit 0), otherwise hands argv to
-    # Dry::CLI for command dispatch and translates the last Outcome to
-    # a process exit code. A `Interrupt` raised from inside command
-    # dispatch (most commonly: a SIGINT during a long-running
-    # `Shell.run`, e.g. at a `git` username prompt or mid-clone) is
-    # caught here and mapped to a clean exit code 130 (128 + SIGINT)
-    # with a single human line on stderr — the G2 ^C-hygiene fix
-    # (Slice 6). The reader-thread `IOError` noise that Open3 emits
-    # in the same scenario is suppressed at the `Shell.run` seam
-    # (see `lib/space_src/shell.rb`).
-    def self.run(argv, stdout, stderr)
-      return print_usage(stdout) if TOP_LEVEL_HELP.include?(argv)
-      return print_version(stdout) if VERSION_REQUEST.include?(argv)
-
-      Migration.run(paths: make_paths, err: stderr)
-
-      if bare_query?(argv)
-        paths = make_paths
-        config = Config::Store.load(paths.config_file).success
-        exit_code = Nav.dispatch(argv[0], stdout, stderr, config.base_dir)
-        Kernel.exit(exit_code)
-      end
-
-      begin
-        Dry::CLI.new(Registry).call(arguments: argv, out: stdout, err: stderr)
-        outcome = last_outcome
-        Kernel.exit(outcome&.exit_code || 0)
-      rescue Interrupt
-        # Map a user ^C to a clean exit-130 with a single human line.
-        # `Kernel.exit` raises `SystemExit` (callers/tests can rescue
-        # it to inspect the status). The `at_exit` handlers run,
-        # stdio is flushed, the process exits with code 130. We do
-        # NOT blanket-rescue `StandardError` and we do NOT make
-        # non-interrupt failures exit 0 (the outcome-translation path
-        # above is unchanged for the happy / non-Interrupt failure
-        # paths).
-        stderr.puts "interrupted"
-        Kernel.exit(130)
-      end
-    end
-
-    # Render the top-level command-group listing (reusing Dry::CLI's
-    # own Usage formatter so it stays in sync with the registry) to
-    # stdout and exit 0.
-    def self.print_usage(stdout)
-      stdout.puts Dry::CLI::Usage.call(Registry.get([]))
-      Kernel.exit(0)
-    end
-
-    # Print the gem version to stdout and exit 0.
-    def self.print_version(stdout)
-      stdout.puts Space::Src::VERSION
-      Kernel.exit(0)
-    end
-
-    # Internal: build a Paths instance scoped to the active env
-    # (Thread.current[:space_src_cli_env] || ENV). Every command
-    # uses this so tests can inject a temp home without mutating
-    # the real ENV.
-    def self.make_paths
-      Paths.new(environment: env)
-    end
-
-    # The Dry::CLI::Registry-extended module. The subcommand files
-    # (cli/repo.rb, cli/org.rb, …) call `register "x" do |p| ... end`
-    # on this module at load time.
-    module Registry
-      extend Dry::CLI::Registry
-    end
-  end
-end
-
-# Subcommand files — each defines its command classes and
-# registers them under their group prefix.
-require "space_src/cli/repo"
-require "space_src/cli/org"
-require "space_src/cli/sync"
-require "space_src/cli/status"
-require "space_src/cli/config"
-require "space_src/cli/daemon"
-require "space_src/cli/clone"
-require "space_src/cli/shell"
-require "space_src/nav"