agentilda 2.0.1 → 2.0.4

data/lib/agentilda/resync.rb

@@ -1,426 +0,0 @@
-# frozen_string_literal: true
-
-module Agentilda
-  # Reconciling what is recorded with what is true.
-  #
-  # Both resyncs are dry-run by default and both refuse to act where they are
-  # not certain, because both write to things other people join on: folder
-  # names, and pull request titles.
-  module Resync
-    # `resync dirs` — makes every folder's name say what the folder is.
-    #
-    # Two things can be wrong with a name, and both are repaired here:
-    #
-    # - **The emoji is wrong** — the contents justify a different state. A
-    #   folder whose status already holds is left alone, which is what stops
-    #   ⭕️ Blocked and 🅱️ Product Blocked — deliberately identical invariants,
-    #   distinguished only by the name — from collapsing into one.
-    # - **The spelling is not canonical** — a folder written `018-⚪️--foo`
-    #   before the `NNN.MM` padding rule or the ` → ` separator, or
-    #   `18.1-⚪️--foo` by hand. Unpadded numbers read fine and sort wrong —
-    #   `018.09` < `018.1` < `018.10` puts a single mixed-width folder in the
-    #   middle of the range. Both are renamed, to `018.00-⚪️ → foo` and
-    #   `018.01-⚪️ → foo`.
-    #
-    # The repairs are applied in that order reversed, as **up to two renames
-    # per folder**: first the spelling, under the status the folder already
-    # claims — which is how a `--`-era folder migrates to the ` → ` form —
-    # and only then the status its contents justify. Both renames aim at
-    # {Feature.plan_dirname}, so they cannot disagree about the final name;
-    # splitting them keeps each auditable on its own, instead of one report
-    # line where a spelling migration also appears to have opinions about
-    # the state of the work.
-    class Dirs
-      # A proposed rename.
-      #
-      # @!attribute [r] dirname
-      #   @return [String] the folder as it stands
-      # @!attribute [r] from
-      #   @return [Symbol] the state it claims
-      # @!attribute [r] to
-      #   @return [Symbol] the state its contents justify
-      # @!attribute [r] source
-      #   @return [String] absolute path now
-      # @!attribute [r] target
-      #   @return [String] absolute path after
-      # @!attribute [r] reason
-      #   @return [String] why the current name is wrong
-      Change = Data.define(:dirname, :from, :to, :source, :target, :reason) do
-        # @return [String] a single auditable line — `⇒` rather than `→`,
-        #   which the folder names themselves now contain
-        def to_s = "#{dirname} ⇒ #{File.basename(target)}  (#{reason})"
-      end
-
-      # The state a folder's contents justify, or the one it claims when
-      # nothing fits. What a rename moves toward, and what the dispatcher
-      # reads on a dry run, which renames nothing, so the preview still
-      # names the agents a real run would start.
-      #
-      # @param subject [Agentilda::Subject]
-      # @return [Agentilda::Status]
-      def self.target(subject) = subject.best_fit || subject.status
-
-      # @param tree [Agentilda::Tree]
-      # @param except [Array<String>] ordinals to leave alone however wrong
-      #   their names are: the dispatcher passes the plans an agent is
-      #   working in right now
-      def initialize(tree:, except: [])
-        @tree = tree
-        @except = except.map(&:to_s)
-      end
-
-      # @return [Agentilda::Tree]
-      attr_reader :tree
-
-      # What would change, without changing anything. A folder can appear
-      # twice: its spelling migration first, then its status correction.
-      #
-      # @return [Array<Agentilda::Resync::Dirs::Change>]
-      def plan
-        tree.subjects.flat_map do |subject|
-          @except.include?(subject.feature.ordinal.to_s) ? [] : changes_for(subject)
-        end
-      end
-
-      # @param commit [Boolean] actually rename
-      # @return [Array<Agentilda::Resync::Dirs::Change>] what was proposed
-      def call(commit: false)
-        changes = plan
-        return changes unless commit
-
-        UI.stepping(changes, "Renaming") { |change| rename(change) }
-        tree.reload
-        changes
-      end
-
-      private
-
-      # A folder moves when the name it has is not the name it should have.
-      # {target} says what that name is; this says how to get there, as up
-      # to two renames applied in order. The status rename starts from where
-      # the spelling rename left the folder, not from where it stands now,
-      # so committing the steps sequentially never renames a path that has
-      # already moved out from under it.
-      #
-      # @param subject [Agentilda::Subject]
-      # @return [Array<Agentilda::Resync::Dirs::Change>] empty when the name
-      #   is already right
-      def changes_for(subject)
-        feature = subject.feature
-        fit = self.class.target(subject)
-        steps = []
-
-        spelled = feature.dirname_as(subject.status)
-        if spelled != feature.dirname
-          steps << step(feature,
-            from:   subject.status,
-            to:     subject.status,
-            source: feature.path,
-            reason: spelling_reason(feature))
-        end
-
-        if fit.key != subject.status.key
-          source = steps.empty? ? feature.path : steps.last.target
-          steps << step(feature,
-            from:   subject.status,
-            to:     fit,
-            source:,
-            reason: subject.violation || "contents now justify #{fit.label}")
-        end
-
-        steps
-      end
-
-      # @param feature [Agentilda::Feature]
-      # @param from [Agentilda::Status]
-      # @param to [Agentilda::Status]
-      # @param source [String] absolute path the rename starts from
-      # @param reason [String]
-      # @return [Agentilda::Resync::Dirs::Change]
-      def step(feature, from:, to:, source:, reason:)
-        Change.new(
-          dirname: File.basename(source),
-          from:    from.key,
-          to:      to.key,
-          source:,
-          target:  File.join(File.dirname(feature.path), feature.dirname_as(to)),
-          reason:
-        )
-      end
-
-      # @param feature [Agentilda::Feature]
-      # @return [String] why the spelling is wrong, status aside
-      def spelling_reason(feature)
-        return "#{feature.dirname_ordinal} is not padded to #{feature.ordinal}" unless feature.padded?
-
-        "name is not in canonical NNN.MM-<emoji> → <slug> form"
-      end
-
-      # A rename that finds its target occupied has not happened, and saying
-      # nothing about it would leave the folder misnamed with a report
-      # claiming otherwise. Two folders can want the same canonical name —
-      # `018-⚪️--foo` and `018.00-⚪️ → foo` are the same plan written twice.
-      #
-      # @param change [Agentilda::Resync::Dirs::Change]
-      # @return [void]
-      # @raise [Agentilda::Error] when the target name is already taken
-      def rename(change)
-        return if Agentilda.move_directory(change.source, change.target)
-
-        raise Error, "cannot rename #{change.dirname} — #{File.basename(change.target)} already exists"
-      end
-    end
-
-    # `resync prs` — puts an `[NNN.MM]` prefix on every pull request title that
-    # lacks one, and `[DEV.00]` on the ones that implement no plan.
-    #
-    # The resolution order is the branch name first, then the diff, and only
-    # when the diff touches exactly one plan. Anything else is reported for a
-    # human and never edited: `pull-requests.md` is generated from these
-    # titles, and a wrong number files work under a plan that did not do it,
-    # leaving the plan that did looking untouched.
-    class Prs
-      # The marker this tool used to write, now replaced. A title wearing it is
-      # rewritten in place: the assertion it makes — "this belongs to no
-      # specification" — is still true and still somebody's deliberate call,
-      # so it is restamped rather than re-resolved.
-      STALE = /\A\[#{Regexp.escape(Agentilda::STALE_NO_PLAN_PREFIX)}\]\s*/
-
-      # Titles that already carry a prefix — a plan number, the no-plan marker,
-      # or the legacy `[XXX]`.
-      PREFIXED = /\A\[(?:\d{3}(?:\.\d{2})?|#{Agentilda::NO_PLAN_PREFIX}|XXX)\](?:\([A-Z]\))?\s/
-
-      # Finds a plan number in a branch name: `kig/018.01-verify`, `002-slug`.
-      BRANCH_PATTERN = %r{(?:\A|[/\-_])(\d{3}(?:\.\d{2})?)(?:\z|[-_])}
-
-      # A proposed retitle.
-      #
-      # @!attribute [r] number
-      #   @return [Integer] the pull request
-      # @!attribute [r] title
-      #   @return [String] as it stands
-      # @!attribute [r] new_title
-      #   @return [String, nil] nil when nothing may safely be done
-      # @!attribute [r] ordinal
-      #   @return [Agentilda::Ordinal, nil]
-      # @!attribute [r] reason
-      #   @return [String] how it was resolved, or why it was not
-      # @!attribute [r] ambiguous
-      #   @return [Boolean] a human must decide; never edited
-      # @!attribute [r] assumed
-      #   @return [Boolean] "no plan" was inferred, not asserted by the author
-      Change = Data.define(:number, :title, :new_title, :ordinal, :reason, :ambiguous, :assumed, :adopted) do
-        # @return [Boolean]
-        def ambiguous? = ambiguous
-
-        # @return [Boolean]
-        def assumed? = assumed
-
-        # @return [Boolean] whether a plan folder was minted for this one
-        def adopted? = adopted
-
-        # @return [Boolean] safe to apply without a human looking
-        def applicable? = !ambiguous && !new_title.nil?
-      end
-
-      # @param tree [Agentilda::Tree]
-      # @param github [Agentilda::GitHub]
-      # @param adopt [Boolean] give a plan folder to every pull request that
-      #   resolves to none, rather than flagging it and moving on
-      # @param root [String, nil] repository root, for reading branches
-      def initialize(tree:, github: GitHub.new, adopt: true, root: nil)
-        @tree = tree
-        @github = github
-        @adopt = adopt
-        @root = root
-      end
-
-      # @return [Boolean]
-      def adopt? = @adopt
-
-      # @return [Agentilda::Tree]
-      attr_reader :tree
-
-      # @return [Agentilda::GitHub]
-      attr_reader :github
-
-      # What would change, without changing anything.
-      #
-      # @return [Array<Agentilda::Resync::Prs::Change>]
-      def plan
-        restamps + resolve(candidates).then { |changes| adopt? ? with_adoptions(changes) : changes }
-      end
-
-      # @return [Array<Agentilda::Resync::Prs::Change>]
-      def restamps = stale.map { |pull| restamped(pull) }
-
-      # @param commit [Boolean] actually retitle, and mint the folders
-      # @return [Array<Agentilda::Resync::Prs::Change>] what was proposed
-      def call(commit: false)
-        changes = resolve(candidates)
-        return restamps + (adopt? ? with_adoptions(changes) : changes) unless commit
-
-        changes = with_adoptions(changes, create: true) if adopt?
-        changes = restamps + changes
-        applicable = changes.select(&:applicable?)
-        UI.stepping(applicable, "Retitling") { |c| github.retitle(number: c.number, title: c.new_title) }
-        changes
-      end
-
-      # @return [Array<Agentilda::Adoption>] the adopter, memoized
-      def adoption = @adoption ||= Adoption.new(tree:, github:, root: @root)
-
-      private
-
-      # @return [Array<Hash>] pull requests with no prefix yet
-      def candidates
-        github.pulls.reject { |pr| pr[:title].to_s.match?(PREFIXED) || pr[:title].to_s.match?(STALE) }
-      end
-
-      # @return [Array<Hash>] pull requests still wearing the old marker
-      def stale = github.pulls.select { |pr| pr[:title].to_s.match?(STALE) }
-
-      # @param pull [Hash]
-      # @return [Agentilda::Resync::Prs::Change]
-      def restamped(pull)
-        Change.new(number: pull[:number],
-          title: pull[:title],
-          ordinal: nil,
-          ambiguous: false,
-          new_title: pull[:title].sub(STALE, "[#{Agentilda::NO_PLAN_PREFIX}] "),
-          reason: "the no-plan marker is now [#{Agentilda::NO_PLAN_PREFIX}]",
-          assumed: false,
-          adopted: false)
-      end
-
-      # @param pulls [Array<Hash>]
-      # @return [Array<Agentilda::Resync::Prs::Change>]
-      def resolve(pulls) = pulls.map { |pr| change_for(pr) }
-
-      # Replace every flagged change with one that points at a plan folder the
-      # pull request now owns. The unresolvable ones were unresolvable because
-      # no plan described them — so the answer is a plan, not a shrug.
-      #
-      # @param changes [Array<Agentilda::Resync::Prs::Change>]
-      # @param create [Boolean] mint the folders, rather than only saying so
-      # @return [Array<Agentilda::Resync::Prs::Change>]
-      def with_adoptions(changes, create: false)
-        orphans = changes.select(&:ambiguous?)
-        return changes if orphans.empty?
-
-        pulls = orphans.map { |c| pull_by_number.fetch(c.number) }
-        adoptees = create ? adoption.call(pulls) : adoption.plan(pulls)
-        by_number = adoptees.to_h { |a| [a.pull[:number], a] }
-
-        changes.map { |c| c.ambiguous? && by_number[c.number] ? adopted(c, by_number[c.number]) : c }
-      end
-
-      # @return [Hash{Integer => Hash}]
-      def pull_by_number = @pull_by_number ||= candidates.to_h { |pr| [pr[:number], pr] }
-
-      # @param change [Agentilda::Resync::Prs::Change]
-      # @param adoptee [Agentilda::Adoption::Adoptee]
-      # @return [Agentilda::Resync::Prs::Change]
-      def adopted(change, adoptee)
-        change.with(
-          ordinal:   adoptee.ordinal,
-          new_title: "#{adoptee.ordinal.to_prefix} #{change.title}",
-          reason:    "#{change.reason} — adopted into #{adoptee.dirname}",
-          ambiguous: false,
-          adopted:   true
-        )
-      end
-
-      # @param pull [Hash]
-      # @return [Agentilda::Resync::Prs::Change]
-      def change_for(pull)
-        from_branch(pull) || from_files(pull) || no_plan(pull)
-      end
-
-      # 1. The branch name — the one moment the author certainly knew.
-      #
-      # @param pull [Hash]
-      # @return [Agentilda::Resync::Prs::Change, nil]
-      def from_branch(pull)
-        match = BRANCH_PATTERN.match(pull[:branch].to_s) or return nil
-        ordinal = Ordinal.parse(match[1])
-
-        unless tree.include?(ordinal)
-          return flag(pull, "branch names #{ordinal}, which has no folder in #{File.basename(tree.dir)}")
-        end
-
-        resolved(pull, ordinal, "branch #{pull[:branch]}")
-      end
-
-      # 2. The diff, and only when it touches exactly one plan.
-      #
-      # @param pull [Hash]
-      # @return [Agentilda::Resync::Prs::Change, nil]
-      def from_files(pull)
-        touched = Array(pull[:files]).filter_map { |path| ordinal_for_path(path) }.uniq
-        case touched.size
-        when 1 then resolved(pull, touched.first, "diff touches only #{touched.first}")
-        when 0 then nil
-        else flag(pull, "diff touches #{touched.join(", ")} and none is obviously primary")
-        end
-      end
-
-      # @param path [String] a path from the diff
-      # @return [Agentilda::Ordinal, nil]
-      def ordinal_for_path(path)
-        parts = path.to_s.split("/")
-        index = parts.index(Agentilda::PLANS_DIR) or return nil
-        folder = parts[index + 1] or return nil
-        return nil if parts.length <= index + 2 # a file directly under .plans belongs to no plan
-
-        ordinal = Ordinal.from_dirname(folder)
-        ordinal if ordinal && tree.include?(ordinal)
-      end
-
-      # @param pull [Hash]
-      # @param ordinal [Agentilda::Ordinal]
-      # @param why [String]
-      # @return [Agentilda::Resync::Prs::Change]
-      def resolved(pull, ordinal, why)
-        Change.new(number: pull[:number],
-          title: pull[:title],
-          ordinal:,
-          reason: why,
-          new_title: "#{ordinal.to_prefix} #{pull[:title]}",
-          ambiguous: false,
-          assumed: false,
-          adopted: false)
-      end
-
-      # Nothing resolved, so this is developer work — but that is an assertion
-      # about intent, so it is marked as assumed rather than stated as fact.
-      #
-      # @param pull [Hash]
-      # @return [Agentilda::Resync::Prs::Change]
-      def no_plan(pull)
-        Change.new(number: pull[:number],
-          title: pull[:title],
-          ordinal: nil,
-          new_title: "[#{Agentilda::NO_PLAN_PREFIX}] #{pull[:title]}",
-          reason: "no plan resolved from the branch or the diff",
-          ambiguous: false,
-          assumed: true,
-          adopted: false)
-      end
-
-      # @param pull [Hash]
-      # @param why [String]
-      # @return [Agentilda::Resync::Prs::Change]
-      def flag(pull, why)
-        Change.new(number: pull[:number],
-          title: pull[:title],
-          new_title: nil,
-          ordinal: nil,
-          reason: why,
-          ambiguous: true,
-          assumed: false,
-          adopted: false)
-      end
-    end
-  end
-end

data/lib/agentilda/roster.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require "agentilda/status"
-require "agentilda/state_machine"
-
-module Agentilda
-  # `agentilda agents` — who the specialists are and what each is offered
-  # work from. Reading one in full is {Viewer}'s job: the definition file is
-  # already the whole truth, so `agents describe` opens it rather than
-  # restating it.
-  #
-  # {#list} returns a string and prints nothing, the same bargain {Reporter}
-  # makes, so the caller decides where the text goes and the table stays
-  # pipeable.
-  #
-  # Everything here is read from the definition files. Nothing about a
-  # specialty is restated in Ruby, because a second copy of "who does what" is
-  # a copy that drifts from the frontmatter the loop actually routes on.
-  class Roster
-    # Columns, so the header and the rows cannot drift apart.
-    HEADINGS = ["Agent", "Handles", "Advances to", "Model"].freeze
-
-    # What an agent with no `advances_to` is, in the one word that explains why
-    # `run` never offers it work.
-    READ_ONLY = "read-only"
-
-    # What an agent that handles only {StateMachine::SETTLED} states advances
-    # to. `run` never starts it; a command does, and `resync` then names the
-    # folder by what its files justify.
-    BY_CONTENTS = "by contents"
-
-    # @param agents [Agentilda::Agents]
-    def initialize(agents: Agents.new)
-      @agents = agents
-    end
-
-    # @return [Agentilda::Agents]
-    attr_reader :agents
-
-    # One row per agent, in name order, framed by {UI.table}.
-    #
-    # @return [String] newline-terminated
-    def list
-      all = agents.all
-      return "No agent definitions in #{agents.dir}\n" if all.empty?
-
-      UI.table(all.map { |agent| row(agent) }, header: HEADINGS)
-    end
-
-    private
-
-    # A state as its words alone, deliberately without the emoji that every
-    # other rendering of a state carries. The table widget pads a cell to a
-    # width it measures in characters, while the terminal draws a status emoji
-    # in two cells; the variation-selector ones (⭕️ 🅱️ ⚪️ ⭐️ 🕰️) are two
-    # characters drawn in two cells, so no single count is right for all of
-    # them. A row carrying one lands short or long and the frame stops lining
-    # up. The label says the same thing unambiguously, and is worth more than
-    # the emoji is. {Reporter} lays its own columns out with {UI.fit} and so
-    # keeps the emoji.
-    #
-    # @param key [Symbol]
-    # @return [String]
-    def state(key)
-      status = STATUS_BY_KEY[key] or return key.to_s
-      status.label
-    end
-
-    # @param agent [Agentilda::Agent]
-    # @return [String]
-    def handles(agent) = agent.handles.map { |key| state(key) }.join(", ")
-
-    # @param agent [Agentilda::Agent]
-    # @return [String]
-    def advances(agent)
-      return state(agent.advances_to) if agent.advances_to
-      return BY_CONTENTS if agent.handles.any? && agent.handles.all? { |key| StateMachine::SETTLED.include?(key) }
-
-      READ_ONLY
-    end
-
-    # The widget measures and pads the cells, so they arrive painted only.
-    #
-    # @param agent [Agentilda::Agent]
-    # @return [Array<String>] one cell per entry in {HEADINGS}
-    def row(agent)
-      [UI.paint(agent.name, :bright_cyan),
-       handles(agent),
-       UI.paint(advances(agent), agent.read_only? ? :bright_black : :green),
-       UI.paint(agent.model.to_s, :bright_black)]
-    end
-  end
-end

data/lib/agentilda/runner.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-module Agentilda
-  # Drives specialist agents over a `.plans` tree until nothing is left to
-  # dispatch.
-  #
-  # The loop itself is {Dispatcher}. This holds what the loop needs about
-  # the run: the tree and its scope, the roster, the executor, how many run
-  # at once, where each plan is checked out, and how a finished plan is
-  # published. Blocked plans (⭕️ 🅱️) are stepped around, never assigned.
-  class Runner
-    # What one agent did to one plan.
-    Attempt = Data.define(:ordinal,
-      :agent,
-      :from,
-      :to,
-      :ok,
-      :note,
-      :up,
-      :down,
-      :subagents,
-      :delegated,
-      :seconds,
-      :round,
-      :file,
-      :model,
-      :status) do
-      def initialize(round: 1, file: "", model: nil, status: nil, **rest) = super
-
-      # @return [Boolean] whether the plan actually moved
-      def advanced? = ok && from != to
-    end
-
-    # One unit of work: an agent, a plan, and the checkout it happens in.
-    Task = Data.define(:agent, :subject, :root, :checkout, :round) do
-      # @return [Hash] columns for the log
-      def log_fields
-        { plan: subject.feature.ordinal.to_s, status: subject.status.to_s,
-         agent: agent.name, round: format("%02d", round) }
-      end
-    end
-
-    # @param rounds [Integer, nil] `--rounds`, capping each agent's own
-    # @param state [Agentilda::StateFile, nil]
-    # @param sleeper [Proc]
-    # @param on_board [Proc, nil]
-    def initialize(tree:, executor:, agents: Agents.new, isolation: :shared, jobs: 1, worktree: nil,
-      plans: nil, publisher: nil, dry_run: false, rounds: nil, state: nil,
-      sleeper: ->(seconds) { sleep(seconds) }, on_board: nil)
-      @tree = tree
-      @executor = executor
-      @agents = agents
-      @isolation = isolation
-      @worktree = worktree
-      @plans = plans
-      @publisher = publisher
-      @dry_run = dry_run
-      @rounds = rounds
-      @state = dry_run ? nil : state
-      @sleeper = sleeper
-      @on_board = on_board
-      @attempts = []
-      @jobs = isolated? ? jobs : 1
-    end
-
-    attr_reader :jobs, :worktree, :tree, :attempts, :executor, :agents
-
-    # @return [Boolean]
-    def isolated? = @isolation == :worktree
-
-    # @return [Boolean]
-    def dry_run? = @dry_run
-
-    # @return [String] the repository root
-    def root = isolated? ? worktree.root : shared_root
-
-    # @param subject [Agentilda::Subject]
-    # @return [Boolean]
-    def in_scope?(subject) = @plans.nil? || @plans.include?(subject.feature.ordinal)
-
-    # @return [Array<Agentilda::Subject>]
-    def in_scope = tree.subjects.select { |s| in_scope?(s) }
-
-    # Run until nothing is dispatchable.
-    #
-    # @yieldparam dispatcher [Agentilda::Dispatcher] before it runs, so a
-    #   console can attach itself and reach the running jobs
-    # @return [Array<Agentilda::Runner::Attempt>]
-    def call
-      dispatcher = Dispatcher.new(runner: self, state: @state, rounds: @rounds, sleeper: @sleeper, on_board: @on_board)
-      yield dispatcher if block_given?
-      @attempts = dispatcher.run
-    end
-
-    # @return [Array<Agentilda::Subject>]
-    def blocked = in_scope.select { |s| %i[blocked product_blocked].include?(s.status.key) }
-
-    # @return [Boolean]
-    def settled? = in_scope.all? { |s| StateMachine::SETTLED.include?(s.status.key) }
-
-    # A dry run gets the shared root whatever the isolation says: nothing
-    # runs in the checkout, and `git worktree add` is a side effect a
-    # preview must not have. It also fails outright when the plan's branch
-    # is the one checked out where the run was typed, which is where a dry
-    # run of that plan is typed.
-    #
-    # @return [Agentilda::Runner::Task]
-    def prepare(agent, subject, round)
-      return Task.new(agent:, subject:, root: shared_root, checkout: nil, round:) if !isolated? || dry_run?
-
-      checkout = worktree.checkout_for(subject.feature)
-      Task.new(agent:, subject:, root: checkout.path, checkout:, round:)
-    end
-
-    # @return [Agentilda::Publisher::Publication, nil]
-    def publish(task, subject)
-      return nil unless @publisher && task.checkout&.dirty?
-
-      publication = @publisher.publish(checkout: task.checkout, subject:)
-      record_pull_request(subject.feature.path, publication) if publication.published?
-      publication
-    end
-
-    private
-
-    # @return [String]
-    def shared_root = File.dirname(tree.dir)
-
-    # @return [void]
-    def record_pull_request(path, publication)
-      number = publication.url.to_s[%r{/pull/(\d+)}, 1]
-      rows = PullRequests.new(dir: path).all.map { |pr|
-        { number: pr.number, title: pr.title, url: pr.url, state: pr.state, body: "" }
-      }
-      rows << { number:, title: publication.title, url: publication.url, state: "Open 🟡", body: "" }
-      PullRequests.upsert(File.join(path, PullRequests::FILENAME), rows)
-    end
-  end
-end