agentilda 2.0.1 → 2.0.4

data/lib/agentilda/plans/status.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module Plans
+    # A folder's state: what it means, which files it cannot be honest without,
+    # and the rule that decides whether the folder may legitimately claim it.
+    #
+    # `invariant` is asked in both directions. {StateMachine} asks it of a
+    # destination before moving there; `resync` and `check` ask it of the current
+    # state, to catch folders whose name has drifted from their contents. One
+    # definition, so the two can never disagree about what a state means.
+    #
+    # @!attribute [r] key
+    #   @return [Symbol] machine-facing name, e.g. `:product_blocked`
+    # @!attribute [r] emoji
+    #   @return [String] as it appears in the folder name
+    # @!attribute [r] label
+    #   @return [String] the human words
+    # @!attribute [r] requires
+    #   @return [Array<String>] files this state cannot be honest without
+    # @!attribute [r] note
+    #   @return [String] one-line meaning, for tables and generated docs
+    # @!attribute [r] invariant
+    #   @return [Proc, nil] `(subject) -> String | nil` — the reason it does not hold
+    Status = Data.define(:key, :emoji, :label, :requires, :note, :invariant) do
+      # @param subject [#file?, #read, #pull_requests]
+      # @return [Boolean]
+      def satisfied_by?(subject) = violation(subject).nil?
+
+      # @param subject [#file?, #read, #pull_requests]
+      # @return [String, nil] why this state is not justified, nil when it is
+      def violation(subject)
+        missing = requires.reject { |f| subject.file?(f) }
+        return "#{label} requires #{missing.map { |f| "`#{f}`" }.join(" and ")}" unless missing.empty?
+
+        invariant&.call(subject)
+      end
+
+      # @return [Boolean] whether nothing may follow this state
+      def terminal? = StateMachine.outbound(key).empty?
+
+      # @return [String] emoji and words, as the tables print it
+      def to_s = "#{emoji} #{label}"
+    end
+
+    # "1 pull request", "3 pull requests".
+    #
+    # @param count [Integer]
+    # @return [String]
+    def self.pull_request_count(count) = "#{count} pull request#{"s" unless count == 1}"
+
+    # What proves a specification has been researched rather than merely
+    # written: the chapter `leah-researcher` contributes. It is a section of
+    # `spec.md` rather than a file of its own because research is not a separate
+    # document — it is the first half of the specification, and splitting it
+    # would leave `yoda-writer` reading two files to write one.
+    RESEARCH_CHAPTER = /^[ \t]{0,3}\#{2,3}[ \t]+Research\b/i
+
+    # What proves `plan.md` holds a plan rather than the blank file
+    # `yoda-writer` leaves for `palpatine-planner`: any section heading. The
+    # ledger notes are stripped first, so an agent's `Started` line does not
+    # count as a plan.
+    PLAN_HEADING = /^[ \t]{0,3}\#{1,3}[ \t]+\S/
+
+    # Variation selectors make ⚪️ and ⚪ different strings that mean the same
+    # thing to a human. Compare with them removed.
+    #
+    # @param str [String, nil]
+    # @return [String]
+    def self.fold_emoji(str) = str.to_s.gsub(/[\u{FE0E}\u{FE0F}\u{200D}]/, "")
+
+    # 🟢 Ready for Review, 👀 In Review and 🔴 Changes Requested are the same
+    # thing on disk — the work exists and at least one pull request is still
+    # open. Which of the three it is lives in the folder name and nowhere else,
+    # so they share one invariant rather than three that could drift apart.
+    #
+    # @param label [String]
+    # @return [Proc]
+    def self.open_pull_request(label)
+      lambda { |subject|
+        return "#{label} requires an open pull request; none are recorded" if subject.pull_requests.empty?
+
+        "#{label}, but every pull request is already merged" if subject.pull_requests.none?(&:open?)
+      }
+    end
+
+    # A question that is still somebody's to answer, written as its own heading:
+    # `## B1`, `## B2`. The number is what `blocked.md` gets referenced by in
+    # conversation and in pull requests, so it is also the only part of the file
+    # a program can count.
+    #
+    # Whoever writes `blocked.md` MUST use this notation. A question written any
+    # other way is invisible to every part of this tool: the folder never becomes
+    # ⭕️, and `unblock` reports a file with nothing in it to drain. {ANSWER_BLOCK}
+    # is the other half of the pair.
+    OPEN_BLOCK = /^[ \t]{0,3}\#{0,4}[ \t]*\**B(\d+)\b/
+
+    # The answer to the question of the same number: `## A1` settles `## B1`.
+    #
+    # Answers are an inbox, not a record. `lando-broker` folds each one into the
+    # document its question was stopping and deletes both, so a `blocked.md`
+    # holding nothing but history must not go on stopping the folder. An `A`
+    # never matches {OPEN_BLOCK}, which is what lets the two live in one file.
+    ANSWER_BLOCK = /^[ \t]{0,3}\#{0,4}[ \t]*\**A(\d+)\b/
+
+    # The numbers named by every heading in +text+ matching +pattern+.
+    #
+    # @param text [String, nil]
+    # @param pattern [Regexp] {OPEN_BLOCK} or {ANSWER_BLOCK}
+    # @return [Array<Integer>] in the order they appear, without duplicates
+    def self.block_numbers(text, pattern)
+      text.to_s.lines.filter_map { |line| line[pattern, 1]&.to_i }.uniq
+    end
+
+    # ⭕️ Technical Block and 🅱️ Product Block are the same thing on disk: a
+    # `blocked.md` still naming at least one question nobody has answered. Which
+    # human is owed the answer lives in the folder name and nowhere else, so the
+    # two share one invariant rather than two that could drift apart.
+    #
+    # This is what lets a block drain in pieces. Answers land in `blocked.md`
+    # one at a time, `lando-broker` moves each into `spec.md` or `plan.md` and
+    # deletes it here, and the folder leaves ⭕️ on the pass that empties the
+    # file, by content rather than by anyone remembering to delete it.
+    #
+    # @param label [String]
+    # @return [Proc]
+    def self.open_block(label)
+      lambda { |subject|
+        "#{label}, but `blocked.md` names no open question" unless subject.read("blocked.md").to_s.match?(OPEN_BLOCK)
+      }
+    end
+
+    # Every state a plan folder may be in, in lifecycle order. That order drives
+    # the legend, the generated documentation and the `--to` help text.
+    #
+    # 🟣 Merged is deliberately absent: it is a pull request's status, not a
+    # folder's, and giving it a folder state invites folders that claim a pull
+    # request's condition as their own.
+    #
+    # Adding a state here, or changing an emoji, makes the hand-drawn
+    # `docs/img/plan-spec-build.png` stale — `just docs` will show you, because
+    # the mermaid source in the generated document moves with this list.
+    STATUSES = [
+      Status.new(
+        key:       :new,
+        emoji:     "⚪️",
+        label:     "New",
+        requires:  %w[spec.md],
+        note:      "a specification exists; it has not been planned yet",
+        invariant: nil
+      ),
+      Status.new(
+        key:       :researched,
+        emoji:     "🔎",
+        label:     "Researched",
+        requires:  %w[spec.md],
+        note:      "the topic has been researched; `spec.md` carries a `## Research` chapter",
+        invariant: lambda { |s|
+          body = s.read("spec.md").to_s
+          "Researched, but `spec.md` has no `## Research` chapter" unless body.match?(RESEARCH_CHAPTER)
+        }
+      ),
+      Status.new(
+        key:       :ready_for_planning,
+        emoji:     "📋",
+        label:     "Ready for Planning",
+        requires:  %w[spec.md plan.md],
+        note:      "the specification is finished; `plan.md` exists and is still blank, waiting for the planner",
+        invariant: lambda { |s|
+          body = Ledger.stripped(s.read("plan.md"))
+          "Ready for Planning, but `plan.md` already holds a plan" if body.match?(PLAN_HEADING)
+        }
+      ),
+      Status.new(
+        key:       :planned,
+        emoji:     "⭐️",
+        label:     "Planned",
+        requires:  %w[spec.md plan.md],
+        note:      "specified and planned; nobody has started building",
+        invariant: lambda { |s|
+          body = Ledger.stripped(s.read("plan.md"))
+          next "Planned, but `plan.md` has no work units yet" unless body.match?(PLAN_HEADING)
+
+          # An open pull request means somebody did start. Without this
+          # clause a ✅ folder found with a new pull request would fall back
+          # to ⭐️, the family's floor, and claim nobody had touched it.
+          open = s.pull_requests.count(&:open?)
+          "Planned, but #{Agentilda::Plans.pull_request_count(open)} already open" if open.positive?
+        }
+      ),
+      # `pull-requests.md` is deliberately absent from `requires` on both of the
+      # building states, though it names the file they are about. That file is
+      # written by opening a pull request, which happens once, when the last
+      # implementer advances the plan to Ready for Review. Requiring the file to
+      # *enter* Building would mean nothing could ever justify entering it, and
+      # `palpatine-planner` finishing `plan.md` would loop forever between itself
+      # and a state it can never actually reach. Ready for Review is where the
+      # file becomes a real requirement, once something has had the chance to
+      # write it.
+      Status.new(
+        key:       :building,
+        emoji:     "🟡",
+        label:     "Building",
+        requires:  %w[spec.md plan.md],
+        note:      "the back end is under way: data, domain and the API the interface will call",
+        invariant: lambda { |s|
+          body = Ledger.stripped(s.read("plan.md"))
+          "Building, but `plan.md` has no work units to build" unless body.match?(PLAN_HEADING)
+        }
+      ),
+      # Two building states rather than one, because the order is not a
+      # preference: an interface is written against an API that already answers.
+      # Splitting them lets each half be built by someone who only has to be good
+      # at that half, and gives the second a working system to build on rather
+      # than a description of one.
+      Status.new(
+        key:       :building_ui,
+        emoji:     "🎨",
+        label:     "Building UI",
+        requires:  %w[spec.md plan.md],
+        note:      "the back end holds; the interface is being built against it",
+        invariant: lambda { |s|
+          body = Ledger.stripped(s.read("plan.md"))
+          "Building UI, but `plan.md` has no work units to build" unless body.match?(PLAN_HEADING)
+        }
+      ),
+      Status.new(
+        key:       :ready_for_review,
+        emoji:     "🟢",
+        label:     "Ready for Review",
+        requires:  %w[spec.md plan.md pull-requests.md],
+        note:      "every pull request is green on CI and waiting for a reviewer",
+        invariant: open_pull_request("Ready for Review")
+      ),
+      Status.new(
+        key:       :in_review,
+        emoji:     "👀",
+        label:     "In Review",
+        requires:  %w[spec.md plan.md pull-requests.md],
+        note:      "a reviewer has picked it up and has not ruled yet",
+        invariant: open_pull_request("In Review")
+      ),
+      Status.new(
+        key:       :rejected,
+        emoji:     "🔴",
+        label:     "Changes Requested",
+        requires:  %w[spec.md plan.md pull-requests.md],
+        note:      "the review asked for fixes; resubmit once they are made",
+        invariant: open_pull_request("Changes Requested")
+      ),
+      Status.new(
+        key:       :approved,
+        emoji:     "✅",
+        label:     "Approved & Merged",
+        requires:  %w[pull-requests.md],
+        note:      "reviewed, approved, and every pull request merged",
+        invariant: lambda { |s|
+          return "Approved & Merged, but no pull requests are recorded" if s.pull_requests.empty?
+
+          open = s.pull_requests.count(&:open?)
+          "Approved & Merged, but #{Agentilda::Plans.pull_request_count(open)} still open" if open.positive?
+        }
+      ),
+      Status.new(
+        key:       :deployed,
+        emoji:     "😎",
+        label:     "Deployed",
+        requires:  %w[deployed.md],
+        note:      "live in production; `deployed.md` names the release, date and SHA",
+        invariant: nil
+      ),
+      Status.new(
+        key:       :rolled_back,
+        emoji:     "😱",
+        label:     "Rolled Back",
+        requires:  %w[rollback.md],
+        note:      "it shipped and was pulled; `rollback.md` names what broke",
+        invariant: nil
+      ),
+      Status.new(
+        key:       :shit,
+        emoji:     "💩",
+        label:     "Scrapped by Review",
+        requires:  %w[rewrite.md],
+        note:      "the review scrapped the work; the plan survives, the pull requests do not",
+        invariant: nil
+      ),
+      Status.new(
+        key:       :blocked,
+        emoji:     "⭕️",
+        label:     "Technical Block",
+        requires:  %w[blocked.md],
+        note:      "cannot proceed; `blocked.md` names what an engineer or the CTO must decide",
+        invariant: open_block("Technical Block")
+      ),
+      Status.new(
+        key:       :product_blocked,
+        emoji:     "🅱️",
+        label:     "Product Block",
+        requires:  %w[blocked.md],
+        note:      "cannot proceed; `blocked.md` names what a product manager must decide",
+        invariant: open_block("Product Block")
+      ),
+      Status.new(
+        key:       :deferred,
+        emoji:     "☢️",
+        label:     "Deferred",
+        requires:  %w[delayed.md],
+        note:      "could proceed and chose not to yet; `delayed.md` must name the trigger",
+        invariant: lambda { |s|
+          body = s.read("delayed.md").to_s
+          "Deferred, but `delayed.md` names no trigger" unless body.match?(/trigger|revisit|when\b|until\b|once\b/i)
+        }
+      ),
+      Status.new(
+        key:       :retroactive,
+        emoji:     "🕰️",
+        label:     "Retroactive",
+        requires:  [],
+        note:      "the feature is live, but has neither a specification nor a plan",
+        invariant: lambda { |s|
+          next "Retroactive, but a `spec.md` already exists — it has been documented" if s.file?("spec.md")
+
+          "Retroactive, but no pull requests are recorded" if s.pull_requests.empty?
+        }
+      ),
+      Status.new(
+        key:       :discarded,
+        emoji:     "❌",
+        label:     "Discarded",
+        requires:  %w[discarded.md],
+        note:      "dropped for good; `discarded.md` says why. A terminal state",
+        invariant: nil
+      )
+    ].freeze
+
+    # Emoji => status, folded so ⚪ and ⚪️ both resolve.
+    STATUS_BY_EMOJI = STATUSES.each_with_object({}) { |s, h| h[fold_emoji(s.emoji)] ||= s }.freeze
+
+    # Symbol => status.
+    STATUS_BY_KEY = STATUSES.to_h { |s| [s.key, s] }.freeze
+
+    # @param emoji [String, nil]
+    # @return [Agentilda::Plans::Status, nil]
+    def self.status_for_emoji(emoji) = STATUS_BY_EMOJI[fold_emoji(emoji)]
+
+    # Resolve a state from the only two names it has: its key, and its emoji.
+    #
+    # There is deliberately no synonym table. A state that also answers to
+    # "star", "green" and "completed" has four names to keep in step with the
+    # folder, the generated docs and the agent frontmatter — and the synonym
+    # table that used to live here went stale pointing six words at a state that
+    # no longer existed.
+    #
+    # @param text [String, Symbol, Agentilda::Plans::Status, nil]
+    # @return [Agentilda::Plans::Status, nil]
+    def self.status(text)
+      return nil if text.nil?
+      return text if text.is_a?(Status)
+
+      key = text.to_s.strip
+      STATUS_BY_KEY[key.to_sym] || status_for_emoji(key)
+    end
+  end
+end

data/lib/agentilda/plans/subject.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module Plans
+    # A plan folder as the state machine sees it: which files exist, what they
+    # say, and which pull requests they record.
+    #
+    # It exists because the invariants ask the same questions repeatedly and
+    # {Feature} is a frozen `Data` with nowhere to memoize the answers.
+    class Subject
+      # @param feature [Agentilda::Plans::Feature]
+      def initialize(feature)
+        @feature = feature
+        @reads = {}
+      end
+
+      # @return [Agentilda::Plans::Feature]
+      attr_reader :feature
+
+      # @return [Agentilda::Plans::Status] the status the folder name claims
+      def status = feature.status
+
+      # @param name [String] a bare filename
+      # @return [Boolean]
+      def file?(name) = File.file?(File.join(feature.path, name))
+
+      # @param name [String]
+      # @return [String, nil] contents, or nil when absent
+      def read(name)
+        @reads.fetch(name) do
+          @reads[name] = file?(name) ? File.read(File.join(feature.path, name), encoding: "UTF-8") : nil
+        end
+      end
+
+      # @return [Array<Agentilda::Plans::PullRequest>]
+      def pull_requests = @pull_requests ||= PullRequests.new(dir: feature.path).all
+
+      # The specification's own Goal section, verbatim and at most two
+      # paragraphs. Anything that paraphrases the spec is a second copy that
+      # drifts; quoting it is not — which is why the pull request body and the
+      # index both read it from here rather than each writing their own.
+      #
+      # @return [Array<String>] paragraphs, empty when there is no Goal to read
+      def goal
+        body = read("spec.md").to_s
+        section = body[/^\#{"#"}{2,3}\s*Goals?\b[^\n]*\n+(.*?)(?=\n\#{"#"}{1,3}\s|\z)/mi, 1]
+
+        paragraphs(section) || paragraphs(body.sub(/\A\s*\#{"#"}[^\n]*\n/, "")) || []
+      end
+
+      # Specifications written before the template existed have no Goal section,
+      # and they are exactly the ones an index most needs to describe. So the
+      # opening prose stands in — skipping headings, quotes, lists and tables,
+      # which describe the document rather than the work.
+      #
+      # @param text [String, nil]
+      # @return [Array<String>, nil] nil when there is no prose to be had
+      def paragraphs(text)
+        found = text.to_s.strip.split(/\n{2,}/)
+                    .map(&:strip)
+                    .reject { |p| p.empty? || p.match?(/\A[\#>|\-*\d`_=]/) }
+                    .first(2)
+
+        found.empty? ? nil : found
+      end
+
+      # The questions `blocked.md` still names, by number.
+      #
+      # Empty means one of two very different things, and a caller that treats
+      # them alike is how a folder with thirty kilobytes of open questions gets
+      # reported as "nothing left open": either there is no `blocked.md` at all,
+      # or there is one whose questions are not written as `## B<n>` and are
+      # therefore invisible to every part of this tool. Ask {#file?} which.
+      #
+      # @return [Array<Integer>]
+      def open_blocks = Agentilda::Plans.block_numbers(read("blocked.md"), OPEN_BLOCK)
+
+      # The answers waiting in `blocked.md`, by number. `## A1` settles `## B1`.
+      #
+      # Waiting, not folded. An `## A<n>` heading is not the same as a settled
+      # question: one may say in its own body that it is a draft pending a
+      # conversation. `lando-broker` makes that call; this only counts headings.
+      #
+      # @return [Array<Integer>]
+      def block_answers = Agentilda::Plans.block_numbers(read("blocked.md"), ANSWER_BLOCK)
+
+      # A `blocked.md` this tool cannot read: the file is there, and not one
+      # question in it is written as `## B<n>`. Nothing can drain it and nothing
+      # currently says so, which is the whole reason this exists.
+      #
+      # @return [Boolean]
+      def unreadable_block? = file?("blocked.md") && open_blocks.empty?
+
+      # @return [String, nil] why the folder's name is not justified
+      def violation = status.violation(self)
+
+      # @return [Boolean] whether the name matches the contents
+      def consistent? = violation.nil?
+
+      # @return [Agentilda::Plans::StateMachine] positioned at the current state
+      def machine = StateMachine.new(self)
+
+      # @return [Array<Symbol>] states reachable right now, guards applied
+      def allowed = machine.allowed
+
+      # @return [Agentilda::Plans::Status, nil] the state these contents justify
+      def best_fit = machine.best_fit
+
+      # Move the folder into +status+ — the side effect a transition *is*.
+      #
+      # The {Feature} is a frozen `Data` holding the old name, so it is replaced
+      # rather than mutated, and the memoized reads go with it.
+      #
+      # @param status [Agentilda::Plans::Status]
+      # @return [Agentilda::Plans::Feature] the feature under its new name
+      # @raise [Agentilda::Error] when the target name is already taken
+      def rename_to(status)
+        return @feature if status.key == @feature.status.key
+
+        target = File.join(File.dirname(@feature.path), @feature.dirname_as(status))
+        unless Agentilda.move_directory(@feature.path, target)
+          raise Error, "cannot rename #{@feature.dirname} — #{File.basename(target)} already exists"
+        end
+
+        @reads = {}
+        @pull_requests = nil
+        @feature = Feature.parse(target) or raise Error, "#{File.basename(target)} is not a plan folder"
+      end
+    end
+  end
+end

data/lib/agentilda/plans/tree.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module Plans
+    # A project's `.plans` directory: the folders in it, decoded and ordered.
+    class Tree
+      # @param dir [String] the `.plans` directory
+      def initialize(dir:)
+        @dir = File.expand_path(dir)
+      end
+
+      # @return [String] absolute path to the `.plans` directory
+      attr_reader :dir
+
+      # @return [Boolean]
+      def exist? = File.directory?(dir)
+
+      # @return [Array<Agentilda::Plans::Feature>] ordered by number
+      def features = @features ||= directories.filter_map { |p| Feature.parse(p) }.sort
+
+      # @return [Array<Agentilda::Plans::Subject>] ordered by number
+      def subjects = @subjects ||= features.map { |f| Subject.new(f) }
+
+      # @return [Array<Agentilda::Plans::Ordinal>]
+      def ordinals = features.map(&:ordinal)
+
+      # Directories that carry no plan number. Reported, never processed.
+      #
+      # @return [Array<String>]
+      def skipped = @skipped ||= directories.reject { |p| Feature.parse(p) }.map { |p| File.basename(p) }
+
+      # Numbers claimed by more than one folder.
+      #
+      # A plan's number is its identity: branch names, pull request titles and
+      # every `pull-requests.md` join on it. Two folders wearing the same number
+      # make every one of those joins ambiguous, and nothing downstream can tell
+      # which folder a `[002.00]` pull request belongs to.
+      #
+      # @return [Hash{Agentilda::Plans::Ordinal => Array<String>}] number => dirnames
+      def duplicates
+        features.group_by(&:ordinal)
+                .select { |_, group| group.size > 1 }
+                .transform_values { |group| group.map(&:dirname) }
+      end
+
+      # @param ordinal [Agentilda::Plans::Ordinal, String]
+      # @return [Agentilda::Plans::Subject, nil]
+      def find(ordinal)
+        wanted = ordinal.is_a?(Ordinal) ? ordinal : Ordinal.parse(ordinal)
+        subjects.find { |s| s.feature.ordinal == wanted }
+      end
+
+      # @return [Boolean] whether a plan with this number exists on disk
+      def include?(ordinal) = !find(ordinal).nil?
+
+      # Forget everything read from disk, so a caller that has just renamed
+      # folders sees the new state.
+      #
+      # @return [self]
+      def reload
+        @features = @subjects = @skipped = nil
+        self
+      end
+
+      private
+
+      # @return [Array<String>] absolute paths of every subdirectory
+      def directories
+        return [] unless exist?
+
+        Dir.children(dir)
+           .map { |c| File.join(dir, c) }
+           .select { |p| File.directory?(p) }
+           .reject { |p| File.basename(p).start_with?(".") }
+           .sort
+      end
+    end
+  end
+end

data/lib/agentilda/plans.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Agentilda
+  # The plan model: what a `.plans` folder is, which state it claims, and
+  # which transitions it may take. Nothing in here spawns a process or talks
+  # to a network; it reads and renames folders, and that is all.
+  #
+  # The module methods below are the front door. Callers outside this
+  # namespace go through them rather than constructing the classes, so the
+  # classes can be split or renamed without touching the CLI.
+  module Plans
+    module_function
+
+    # @param dir [String] the `.plans` directory
+    # @return [Agentilda::Plans::Tree]
+    def tree(dir = Agentilda::PLANS_DIR) = Tree.new(dir:)
+
+    # @param feature [Agentilda::Plans::Feature]
+    # @return [Agentilda::Plans::Subject]
+    def subject(feature) = Subject.new(feature)
+
+    # @param path [String] a plan folder
+    # @return [Agentilda::Plans::Feature, nil]
+    def feature(path) = Feature.parse(path)
+
+    # @param text [String]
+    # @return [Agentilda::Plans::Ordinal, nil]
+    def ordinal(text) = Ordinal.parse(text)
+
+    # @param dir [String] a plan folder
+    # @return [Agentilda::Plans::Mailbox]
+    def mailbox(dir) = Mailbox.new(dir:)
+
+    # @param tree [Agentilda::Plans::Tree]
+    # @param project [String, nil]
+    # @return [Agentilda::Plans::Index]
+    def index(tree:, project: nil) = Index.new(tree:, project:)
+  end
+end