space-architect 8.0.0 → 9.1.0

data/lib/space_src/scm/git.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "time"
-require "space_src/scm/client"
-require "space_src/scm/status"
-require "space_src/shell"
-
-module Space::Src
-  module SCM
-    # Git CLI implementation of SCM::Client. All subprocess work is
-    # delegated to Shell.run (which requires an ambient Async::Task).
-    class Git < Client
-      # Resolve the bare remote's HEAD. First try the local
-      # `origin/HEAD` symbolic ref; if missing/stale, do a one-shot
-      # `git remote set-head origin -a` (network) to refresh it, then
-      # re-read. This is the gotcha path from AGENTS.md: a plain
-      # `git fetch` does NOT update `origin/HEAD`.
-      def default_branch(path)
-        symbolic = read_origin_head(path)
-        return Dry::Monads::Success(symbolic) if symbolic
-
-        refresh = Shell.run("git", "remote", "set-head", "origin", "-a", chdir: path)
-        return refresh if refresh.failure?
-
-        resolved = read_origin_head(path)
-        if resolved
-          Dry::Monads::Success(resolved)
-        else
-          Dry::Monads::Failure({path: path, reason: "could not resolve origin/HEAD after set-head -a"})
-        end
-      end
-
-      def current_branch(path)
-        # `git symbolic-ref --short HEAD` exits non-zero on detached HEAD.
-        result = Shell.run("git", "symbolic-ref", "--short", "HEAD", chdir: path)
-        if result.success?
-          Dry::Monads::Success(result.success.strip)
-        else
-          # Detached HEAD is not a hard failure — report nil.
-          head = Shell.run("git", "rev-parse", "--verify", "HEAD", chdir: path)
-          if head.success?
-            Dry::Monads::Success(nil)
-          else
-            Dry::Monads::Failure({path: path, reason: "no HEAD", stderr: result.failure[:stderr]})
-          end
-        end
-      end
-
-      def last_fetch_at(path)
-        fetch_head = File.join(path, ".git", "FETCH_HEAD")
-        return Dry::Monads::Success(nil) unless File.exist?(fetch_head)
-        Dry::Monads::Success(Time.at(File.mtime(fetch_head).to_i))
-      end
-
-      def fetch(path)
-        Shell.run("git", "fetch", "--prune", "--no-tags", "origin", chdir: path)
-      end
-
-      # `merge --ff-only` refuses on divergence. We additionally check
-      # the rev-list left/right count first so we can surface a clean
-      # "diverged" failure with diagnostic info, not just a git error
-      # string.
-      def fast_forward(path, default_branch)
-        upstream = "origin/#{default_branch}"
-        counts = Shell.run("git", "rev-list", "--left-right", "--count", "HEAD...#{upstream}", chdir: path)
-        return counts if counts.failure?
-
-        left, right = counts.success.strip.split("\t").map(&:to_i)
-        if left > 0
-          return Dry::Monads::Failure({
-            path: path,
-            reason: "diverged: local is #{left} commit(s) ahead of #{upstream}; not auto-resolving",
-            local_ahead: left,
-            remote_ahead: right
-          })
-        end
-
-        if right == 0
-          return Dry::Monads::Success(0)
-        end
-
-        # Do the fetch (cheap; FETCH_HEAD mtime hint logic can skip this
-        # later, but Slice 1 always fetches when asked to fast-forward).
-        fetch_result = fetch(path)
-        return fetch_result if fetch_result.failure?
-
-        merge = Shell.run("git", "merge", "--ff-only", upstream, chdir: path)
-        if merge.success?
-          Dry::Monads::Success(right)
-        else
-          # On --ff-only failure, git leaves the working tree and local
-          # commits intact — the test asserts this.
-          Dry::Monads::Failure({
-            path: path,
-            reason: "fast-forward failed (likely raced divergence)",
-            stderr: merge.failure[:stderr]
-          })
-        end
-      end
-
-      def status(path)
-        result = Shell.run("git", "status", "--porcelain=v2", "--branch", "--untracked-files=normal", chdir: path)
-        return result if result.failure?
-
-        parsed = parse_porcelain_v2(result.success)
-        Dry::Monads::Success(parsed)
-      end
-
-      def clone(url, dest)
-        parent = File.dirname(dest)
-        FileUtils.mkdir_p(parent)
-        result = Shell.run("git", "clone", url, dest)
-        if result.success?
-          Dry::Monads::Success(dest)
-        else
-          Dry::Monads::Failure({url: url, dest: dest, stderr: result.failure[:stderr]})
-        end
-      end
-
-      # `git switch <branch>`. `git switch` aborts on a dirty tree by
-      # default (man git-switch: "The operation is aborted however if
-      # the operation leads to loss of local changes"), so a nonzero
-      # exit here most likely means the caller violated the engine's
-      # dirty-tree guard. We surface that as a Failure with the
-      # captured stderr so the engine / log can diagnose it.
-      def switch(path, branch)
-        result = Shell.run("git", "switch", branch, chdir: path)
-        if result.success?
-          Dry::Monads::Success(branch)
-        else
-          Dry::Monads::Failure({path: path, branch: branch, reason: "git switch refused", stderr: result.failure[:stderr]})
-        end
-      end
-
-      # Handle an unborn (empty) local clone. If the remote has no
-      # branches, the repo is already a valid empty clone — return
-      # Success(:empty) with no mutation. If the remote has gained
-      # commits, fetch and fast-forward the unborn branch into them.
-      #
-      # `git ls-remote --heads origin` is the authoritative
-      # empty-vs-error discriminator: exit 0 + empty stdout means the
-      # remote truly has no branches; exit 0 + output means it has
-      # commits; non-zero exit means a real network/probe error.
-      def sync_empty(path)
-        ls = Shell.run("git", "ls-remote", "--heads", "origin", chdir: path)
-        return ls if ls.failure?
-
-        return Dry::Monads::Success(:empty) if ls.success.strip.empty?
-
-        fetch_result = fetch(path)
-        return fetch_result if fetch_result.failure?
-
-        branch_result = default_branch(path)
-        return branch_result if branch_result.failure?
-
-        upstream = "origin/#{branch_result.success}"
-        merge = Shell.run("git", "merge", "--ff-only", upstream, chdir: path)
-        if merge.success?
-          Dry::Monads::Success(:fast_forwarded)
-        else
-          Dry::Monads::Failure({path: path, reason: "ff merge into unborn branch failed", stderr: merge.failure[:stderr]})
-        end
-      end
-
-      private
-
-      # `git symbolic-ref --short refs/remotes/origin/HEAD` returns
-      # `origin/<branch>` (the short form of `refs/remotes/origin/<branch>`);
-      # callers want the bare branch name. Returns nil when origin/HEAD
-      # is unset.
-      def read_origin_head(path)
-        result = Shell.run("git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD", chdir: path)
-        return nil unless result.success?
-        line = result.success.strip
-        return nil if line.empty?
-        line.sub(%r{\Aorigin/}, "")
-      end
-
-      # Parse `git status --porcelain=v2 --branch --untracked-files=normal`.
-      # v2 grammar (from the git-status man page):
-      #   # branch.oid <commit-ish> | (initial)
-      #   # branch.head <name> | (detached)
-      #   # branch.upstream <upstream-branch>
-      #   # branch.ab +<ahead> -<behind>
-      #   1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
-      #   2 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path><TAB><origPath>
-      #   u <XY> <sub> <m1> <m2> <m3> <mW> <h1> <h2> <h3> <path>
-      #   ? <path>
-      #   ! <path>
-      def parse_porcelain_v2(output)
-        branch = nil
-        upstream = nil
-        ahead = 0
-        behind = 0
-        detached = false
-        unborn = false
-        entries = []
-
-        output.each_line do |raw|
-          line = raw.chomp
-          next if line.empty?
-          case line
-          when /\A# branch\.oid (.+)/
-            unborn = (Regexp.last_match(1) == "(initial)")
-          when /\A# branch\.head (.+)/
-            branch = Regexp.last_match(1)
-            detached = (branch == "(detached)")
-          when /\A# branch\.upstream (.+)/
-            upstream = Regexp.last_match(1)
-          when /\A# branch\.ab \+(\d+) -(\d+)/
-            ahead = Regexp.last_match(1).to_i
-            behind = Regexp.last_match(2).to_i
-          when /\A[12u?!]/
-            entries << line
-          end
-        end
-
-        Status.new(
-          clean: entries.empty?,
-          branch: branch,
-          upstream: upstream,
-          ahead: ahead,
-          behind: behind,
-          detached: detached,
-          entries: entries,
-          unborn: unborn
-        )
-      end
-    end
-  end
-end

data/lib/space_src/scm/status.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Space::Src
-  module SCM
-    # Value object produced by parsing `git status --porcelain=v2
-    # --branch --untracked-files=normal`. v2 is mandatory (per
-    # AGENTS.md gotcha) so submodule state and rename detection are
-    # stable.
-    #
-    # A working tree is "clean" iff the only porcelain-v2 lines are the
-    # `# branch.*` header lines. Any `1`/`2`/`u`/`?`/`!` line is dirty.
-    Status = Data.define(:clean, :branch, :upstream, :ahead, :behind, :detached, :entries, :unborn) do
-      def initialize(clean:, branch: nil, upstream: nil, ahead: 0, behind: 0, detached: false, entries: [], unborn: false)
-        super
-      end
-
-      def clean? = clean
-
-      def detached? = detached
-
-      def unborn? = unborn
-    end
-  end
-end

data/lib/space_src/shell.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "async"
-require "dry/monads"
-
-module Space::Src
-  # Thin Open3.capture3 wrapper that:
-  #   * requires an ambient Async::Task (so subprocess I/O flows through
-  #     Ruby's Fiber scheduler → kqueue on macOS and is non-blocking);
-  #   * returns a Dry::Monads::Result — Success(stdout) on zero exit,
-  #     Failure({argv:, stderr:, status:}) otherwise.
-  #
-  # Per AGENTS.md: no `async-process`. Per PRD §2: boundaries return
-  # Result, exceptions are for programmer error only.
-  class Shell
-    extend Dry::Monads[:result]
-
-    @run_count = 0
-    @saved_roe = nil
-
-    def self.run(*argv, chdir: nil, env: nil)
-      raise ArgumentError, "Shell.run requires at least argv" if argv.empty?
-      raise "Shell.run must be called inside an ambient Async::Task" unless Async::Task.current?
-
-      full_env = env ? ENV.to_h.merge(env.transform_keys(&:to_s)) : nil
-      opts = {}
-      opts[:chdir] = chdir if chdir
-      # Open3.capture3: env is a leading hash positional arg, not a kwarg.
-      #
-      # Open3.capture3 spawns the child with two internal reader
-      # threads (one for stdout, one for stderr; see
-      # `rubylibdir/open3.rb` ~L644: `out_reader = Thread.new { o.read }`
-      # / `err_reader = Thread.new { e.read }`). When the `popen3`
-      # block exits via exception (e.g. the user ^C'd mid-Shell.run
-      # via SIGINT), `popen_run`'s ensure closes the read pipes from
-      # the main thread while those reader threads are still inside
-      # `o.read` / `e.read`. The mid-read close races with the reader
-      # and raises `IOError: stream closed in another thread` in the
-      # reader thread. With the default `Thread.report_on_exception
-      # = true` (since Ruby 2.5), Ruby prints a multi-line backtrace
-      # to stderr for that orphaned thread — exactly the noise
-      # Slice 6 G3 silences.
-      #
-      # We bracket the `Open3.capture3` call with a save/restore of
-      # `Thread.report_on_exception = false`. This is targeted
-      # because, at this code site, the ONLY threads in flight are:
-      #   * the main thread (this method's caller);
-      #   * Async's internal `io_select` thread
-      #     (`async/lib/async/scheduler.rb` L425) — which silences
-      #     its own report (`Thread.current.report_on_exception =
-      #     false` on that thread, not globally);
-      #   * the Open3 reader threads (the source of the noise).
-      # `lib/` has zero `Thread.new` calls; `dry-cli`, `dry-monads`,
-      # `dry-validation`, `dry-struct`, `dry-types`, `dry-schema`,
-      # `xdg` have none either (verified Slice 6 PHASE 0). So we are
-      # NOT hiding any app-owned worker-thread crashes — the only
-      # thread that can raise here is the Open3 reader thread, and
-      # the only thing it can raise is the IOError we explicitly
-      # want to silence. The original value is restored in `ensure`
-      # so we never leak the suppression past this call.
-      # Refcount the active Shell.run calls so the global flag is suppressed
-      # for the entire overlapping window, not just per-fiber. On 0→1: capture
-      # original and set false. On 1→0 (in ensure): restore the original.
-      # Safe without a Mutex: the reactor is single-threaded; fibers only yield
-      # at Open3.capture3's thread-join, never between these plain assignments.
-      if @run_count == 0
-        @saved_roe = Thread.report_on_exception
-        Thread.report_on_exception = false
-      end
-      @run_count += 1
-      begin
-        stdout, stderr, status = if full_env
-          Open3.capture3(full_env, *argv, **opts)
-        else
-          Open3.capture3(*argv, **opts)
-        end
-      ensure
-        @run_count -= 1
-        Thread.report_on_exception = @saved_roe if @run_count == 0
-      end
-
-      if status.success?
-        Success(stdout)
-      else
-        Failure({argv: argv, stderr: stderr, status: status.exitstatus})
-      end
-    end
-  end
-end

data/lib/space_src/shell_integration.rb

@@ -1,321 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "pathname"
-
-module Space::Src
-  # Generates the standalone `src` fish shell integration and completions.
-  # All paths resolved through Space::Src::Paths (no external core deps).
-  module ShellIntegration
-    FISH_TEMPLATE = <<~'FISH'
-      # Generated by space-src. Do not edit by hand.
-
-      function src --wraps src --description "Navigate source checkouts"
-          if not set -q __src_compat_checked
-              set -g __src_compat_checked 1
-              set -l __src_installed_version __SRC_VERSION__
-              set -l __src_binary_version (command src --version 2>/dev/null)
-              if test "$__src_binary_version" != "$__src_installed_version"
-                  echo "space-src: shell integration version $__src_installed_version does not match binary version $__src_binary_version; re-run 'src shell fish install'" >&2
-              end
-          end
-
-          switch "$argv[1]"
-              case repo org sync status config daemon clone shell
-                  command src $argv
-                  return $status
-              case '*'
-                  set -l __src_output (command src $argv)
-                  set -l __src_status $status
-
-                  if test (count $__src_output) -gt 0
-                      printf "%s\n" $__src_output
-                  end
-
-                  if test $__src_status -eq 0
-                      set -l __src_target $__src_output[-1]
-                      set __src_target (string replace -r "^~(?=/|$)" $HOME -- $__src_target)
-                      if test -d "$__src_target"
-                          cd "$__src_target"
-                      end
-                  end
-
-                  return $__src_status
-          end
-      end
-    FISH
-
-    FISH_COMPLETIONS = <<~'FISH'
-      # Generated by space-src. Do not edit by hand.
-
-      function __src_complete_command
-          set -l tokens (commandline -opc)
-          set -l index 2
-
-          while test $index -le (count $tokens)
-              set -l token $tokens[$index]
-
-              switch "$token"
-                  case "-*"
-                      set index (math $index + 1)
-                      continue
-                  case "*"
-                      echo $token
-                      return 0
-              end
-          end
-      end
-
-      function __src_complete_needs_command
-          test -z "(__src_complete_command)"
-      end
-
-      function __src_complete_using_command
-          contains -- (__src_complete_command) $argv
-      end
-
-      function __src_complete_first_argument_after
-          set -l commands $argv
-          set -l tokens (commandline -opc)
-          set -l index 2
-          set -l matched_command 0
-
-          while test $index -le (count $tokens)
-              set -l token $tokens[$index]
-
-              switch "$token"
-                  case "-*"
-                      set index (math $index + 1)
-                      continue
-              end
-
-              if test $matched_command -eq 0
-                  if contains -- "$token" $commands
-                      set matched_command 1
-                  else
-                      return 1
-                  end
-              else
-                  echo $token
-                  return 0
-              end
-
-              set index (math $index + 1)
-          end
-
-          return 1
-      end
-
-      function __src_complete_has_first_argument_after
-          set -q argv[1]; or return 1
-          set -l first_argument (__src_complete_first_argument_after $argv)
-          test -n "$first_argument"
-      end
-
-      function __src_complete_second_argument_after
-          set -q argv[1]; or return 1
-          set -l command $argv[1]
-          set -l tokens (commandline -opc)
-          set -l index 2
-          set -l matched_command 0
-          set -l matched_first_argument 0
-
-          while test $index -le (count $tokens)
-              set -l token $tokens[$index]
-
-              switch "$token"
-                  case "-*"
-                      set index (math $index + 1)
-                      continue
-              end
-
-              if test $matched_command -eq 0
-                  test "$token" = "$command"; or return 1
-                  set matched_command 1
-              else if test $matched_first_argument -eq 0
-                  set matched_first_argument 1
-              else
-                  echo $token
-                  return 0
-              end
-
-              set index (math $index + 1)
-          end
-
-          return 1
-      end
-
-      function __src_complete_has_second_argument_after
-          set -q argv[1]; or return 1
-          set -l second_argument (__src_complete_second_argument_after $argv)
-          test -n "$second_argument"
-      end
-
-      function __src_complete_first_argument_is
-          set -q argv[1]; or return 1
-          set -l expected $argv[1]
-          set -e argv[1]
-          test "$(__src_complete_first_argument_after $argv)" = "$expected"
-      end
-
-      function __src_complete_checkouts
-          command src shell complete checkouts 2>/dev/null
-      end
-
-      function __src_complete_shells
-          command src shell complete shells 2>/dev/null
-      end
-
-      complete -c src -f -n "__src_complete_needs_command" -a clone   -d "Clone a repo into the source tree"
-      complete -c src -f -n "__src_complete_needs_command" -a config  -d "Show or update config"
-      complete -c src -f -n "__src_complete_needs_command" -a daemon  -d "Manage the background sync daemon"
-      complete -c src -f -n "__src_complete_needs_command" -a org     -d "Manage tracked GitHub orgs"
-      complete -c src -f -n "__src_complete_needs_command" -a repo    -d "Manage tracked repos"
-      complete -c src -f -n "__src_complete_needs_command" -a shell   -d "Manage shell integration"
-      complete -c src -f -n "__src_complete_needs_command" -a status  -d "Show sync status"
-      complete -c src -f -n "__src_complete_needs_command" -a sync    -d "Sync all tracked repos"
-      complete -c src -f -n "__src_complete_needs_command" -a "(__src_complete_checkouts)" -d "Checkout"
-
-      complete -c src -f -n "__src_complete_using_command config; and not __src_complete_has_first_argument_after config" -a path -d "Print config path"
-      complete -c src -f -n "__src_complete_using_command config; and not __src_complete_has_first_argument_after config" -a show -d "Show config"
-
-      complete -c src -f -n "__src_complete_using_command org; and not __src_complete_has_first_argument_after org" -a add    -d "Add a GitHub org"
-      complete -c src -f -n "__src_complete_using_command org; and not __src_complete_has_first_argument_after org" -a remove -d "Remove a GitHub org"
-      complete -c src -f -n "__src_complete_using_command org; and not __src_complete_has_first_argument_after org" -a list   -d "List tracked orgs"
-
-      complete -c src -f -n "__src_complete_using_command repo; and not __src_complete_has_first_argument_after repo" -a add    -d "Add a repo"
-      complete -c src -f -n "__src_complete_using_command repo; and not __src_complete_has_first_argument_after repo" -a remove -d "Remove a repo"
-      complete -c src -f -n "__src_complete_using_command repo; and not __src_complete_has_first_argument_after repo" -a list   -d "List repos"
-
-      complete -c src -f -n "__src_complete_using_command daemon; and not __src_complete_has_first_argument_after daemon" -a install   -d "Install launchd agent"
-      complete -c src -f -n "__src_complete_using_command daemon; and not __src_complete_has_first_argument_after daemon" -a uninstall -d "Uninstall launchd agent"
-      complete -c src -f -n "__src_complete_using_command daemon; and not __src_complete_has_first_argument_after daemon" -a start     -d "Start the agent"
-      complete -c src -f -n "__src_complete_using_command daemon; and not __src_complete_has_first_argument_after daemon" -a stop      -d "Stop the agent"
-      complete -c src -f -n "__src_complete_using_command daemon; and not __src_complete_has_first_argument_after daemon" -a restart   -d "Restart the agent"
-      complete -c src -f -n "__src_complete_using_command daemon; and not __src_complete_has_first_argument_after daemon" -a status    -d "Show agent status"
-
-      complete -c src -f -n "__src_complete_using_command shell; and not __src_complete_has_first_argument_after shell" -a init     -d "Print shell integration"
-      complete -c src -f -n "__src_complete_using_command shell; and not __src_complete_has_first_argument_after shell" -a fish     -d "Manage fish integration and completions"
-      complete -c src -f -n "__src_complete_using_command shell; and not __src_complete_has_first_argument_after shell" -a complete -d "Print completion candidates"
-
-      complete -c src -f -n "__src_complete_first_argument_is fish shell; and not __src_complete_has_second_argument_after shell" -a install   -d "Install fish integration and completions"
-      complete -c src -f -n "__src_complete_first_argument_is fish shell; and not __src_complete_has_second_argument_after shell" -a uninstall -d "Remove fish integration and completions"
-      complete -c src -f -n "__src_complete_first_argument_is fish shell; and not __src_complete_has_second_argument_after shell" -a path      -d "Print fish integration paths"
-
-      complete -c src -f -n "__src_complete_first_argument_is init shell; and not __src_complete_has_second_argument_after shell" -a "(__src_complete_shells)" -d "Shell"
-      complete -c src -f -n "__src_complete_first_argument_is complete shell; and not __src_complete_has_second_argument_after shell" -a "checkouts shells" -d "Completion kind"
-    FISH
-
-    def self.for(shell)
-      case shell.to_s
-      when "fish"
-        FISH_TEMPLATE.gsub("__SRC_VERSION__", Space::Src::VERSION)
-      else
-        raise "Unsupported shell '#{shell}'. Expected: fish"
-      end
-    end
-
-    def self.completions_for(shell)
-      case shell.to_s
-      when "fish"
-        FISH_COMPLETIONS
-      else
-        raise "Unsupported shell '#{shell}'. Expected: fish"
-      end
-    end
-
-    def self.path_for(shell, env: ENV)
-      case shell.to_s
-      when "fish"
-        Pathname(Paths.new(environment: env).config_home).join("fish", "functions", "src.fish")
-      else
-        raise "Unsupported shell '#{shell}'. Expected: fish"
-      end
-    end
-
-    def self.completions_path_for(shell, env: ENV)
-      case shell.to_s
-      when "fish"
-        Pathname(Paths.new(environment: env).config_home).join("fish", "completions", "src.fish")
-      else
-        raise "Unsupported shell '#{shell}'. Expected: fish"
-      end
-    end
-
-    def self.install(shell, env: ENV, force: false)
-      fn_result = write_managed_file(
-        path: path_for(shell, env:),
-        content: self.for(shell),
-        force: force,
-        description: "fish function"
-      )
-      co_result = write_managed_file(
-        path: completions_path_for(shell, env:),
-        content: completions_for(shell),
-        force: force,
-        description: "fish completions"
-      )
-      fn_result.merge(
-        completions_action: co_result.fetch(:action),
-        completions_path: co_result.fetch(:path)
-      )
-    end
-
-    def self.uninstall(shell, env: ENV, force: false)
-      fn_result = remove_managed_file(
-        path: path_for(shell, env:),
-        content: self.for(shell),
-        force: force,
-        description: "fish function"
-      )
-      co_result = remove_managed_file(
-        path: completions_path_for(shell, env:),
-        content: completions_for(shell),
-        force: force,
-        description: "fish completions"
-      )
-      fn_result.merge(
-        completions_action: co_result.fetch(:action),
-        completions_path: co_result.fetch(:path)
-      )
-    end
-
-    def self.managed_src?(content)
-      content.include?("Generated by space-src")
-    end
-
-    private_class_method def self.write_managed_file(path:, content:, force:, description:)
-      existing = File.read(path) if File.exist?(path)
-
-      if existing && existing != content && !force && !managed_src?(existing)
-        raise "Refusing to overwrite existing #{description} at #{path}. Re-run with --force."
-      end
-
-      if existing == content
-        {action: :unchanged, path: path}
-      else
-        FileUtils.mkdir_p(File.dirname(path))
-        tmp = "#{path}.tmp.#{Process.pid}"
-        begin
-          File.write(tmp, content)
-          File.rename(tmp, path)
-        ensure
-          File.delete(tmp) if File.exist?(tmp)
-        end
-        {action: existing ? :updated : :installed, path: path}
-      end
-    end
-
-    private_class_method def self.remove_managed_file(path:, content:, force:, description:)
-      return {action: :missing, path: path} unless File.exist?(path)
-
-      existing = File.read(path)
-      if existing != content && !force && !managed_src?(existing)
-        raise "Refusing to remove existing #{description} at #{path}. Re-run with --force."
-      end
-
-      FileUtils.rm_f(path)
-      {action: :removed, path: path}
-    end
-  end
-end