jackherd 1.12.7 → 1.14.0

package/src/config/detect.ts

@@ -1,55 +1,80 @@
 import { CLI_NAME } from '../version/release'
+import { DEFAULT_BASE_BRANCH } from './base-branch'
 import { PROJECT_CONFIG_PATH } from './location'
+import { COMMAND_KEYS, type CommandKey } from './schema'
 
-export const PACKAGE_MANAGER = { bun: 'bun', yarn: 'yarn', pnpm: 'pnpm', npm: 'npm' } as const
+export const STACK = { bun: 'bun', yarn: 'yarn', pnpm: 'pnpm', npm: 'npm', composer: 'composer' } as const
 
-export type PackageManager = (typeof PACKAGE_MANAGER)[keyof typeof PACKAGE_MANAGER]
+export type Stack = (typeof STACK)[keyof typeof STACK]
+
+/** A tool choice: the command of the first package the manifest requires. */
+type ToolChoice = readonly (readonly [packageName: string, command: string])[]
+
+type ConfigObject = Record<string, unknown>
+
+/** The blocks of a config that detection fills. */
+type ConfigParts = { commands: ConfigObject; lanes: ConfigObject; check: ConfigObject | undefined }
 
 /** What the kit reads from a repository to fill the values its config leaves out. */
 export type RepositoryFacts = {
-  /** The lock files of `LOCK_FILES` present in the repository root. */
+  /** The lock files of `STACKS` present in the repository root. */
   lockFiles: string[]
   /** Branch names on `origin`, without the remote prefix. */
   remoteBranches: string[]
+  /** The package names the root manifests of the present stacks declare; empty without a readable manifest. */
+  manifestPackages: string[]
+  /** The root markers of `STACKS` present in the repository root (`composer.json`, `package.json`). */
+  manifests: string[]
 }
 
-export type PackageManagerDetection =
-  | { kind: 'found'; manager: PackageManager; lockFile: string }
+/** `manifest`: no lock file yet, but a manifest only one stack has. */
+export type StackDetection =
+  | { kind: 'found'; stack: Stack; lockFile: string }
+  | { kind: 'manifest'; stack: Stack; manifest: string }
   | { kind: 'none' }
   | { kind: 'ambiguous'; lockFiles: string[] }
 
-type DerivedCommands = {
-  test: string
-  typecheck: string
-  lint: string
-  format: string
-  install: string
-  dev: string
-  lintFiles: string
-}
+/** A detection that names one stack, by its lock file or its manifest. */
+export const isDecided = (detection: StackDetection): detection is Extract<StackDetection, { stack: Stack }> =>
+  detection.kind === 'found' || detection.kind === 'manifest'
 
-/** In order of preference within one manager: Bun's text lock before its binary one. */
-export const LOCK_FILES: Record<string, PackageManager> = {
-  'bun.lock': PACKAGE_MANAGER.bun,
-  'bun.lockb': PACKAGE_MANAGER.bun,
-  'yarn.lock': PACKAGE_MANAGER.yarn,
-  'pnpm-lock.yaml': PACKAGE_MANAGER.pnpm,
-  'package-lock.json': PACKAGE_MANAGER.npm,
-}
+type DerivedCommands = Record<CommandKey | 'lintFiles', string>
 
-/** The base branches detection chooses between; any other base is set in the config. */
-const BASE_BRANCH_CANDIDATES = ['main', 'master'] as const
+/** The row of one stack. A command the stack has no tool for is absent from `commands`. */
+export type StackProfile = {
+  /** In order of preference: Bun's text lock before its binary one. */
+  lockFiles: readonly string[]
+  /** The manifest in the repository root. */
+  rootMarker: string
+  /** Whether the stack installs dependencies, jackherd among them, into `node_modules` beside the config. */
+  installsIntoNodeModules: boolean
+  /** Files whose presence says the code is typed or statically analysed. */
+  typeMarkers: readonly string[]
+  testFilePattern: RegExp
+  /** The files a test of this stack covers: its code, never its documents or manifests. */
+  sourceFilePattern: RegExp
+  /** Globs the lint covers; none means every file. */
+  lintGlobs: readonly string[]
+  commands: (manifestPackages: readonly string[]) => Partial<DerivedCommands>
+  /** The words a command of this stack starts with. */
+  commandWords: readonly string[]
+  /** The directory whose binaries a command of this stack starts with, as `vendor/bin/`; absent for none. */
+  binaryDirectory?: string
+  /** The install command that stops at the lock file instead of changing it; absent where the plain install does. */
+  frozenInstall?: string
+  /** The package names a parsed root manifest declares; absent for a stack whose tools are not named by packages. */
+  manifestPackages?: (manifest: unknown) => string[]
+}
 
-/** The base branch when the repository does not decide; the schema's default too. */
-export const DEFAULT_BASE_BRANCH = 'main'
+const NODE_TEST_FILE = /\.(test|spec)\.[cm]?[jt]sx?$/
 
-const COMMAND_KEYS = ['test', 'typecheck', 'lint', 'format', 'install', 'dev'] as const
+const NODE_SOURCE_FILE = /\.[cm]?[jt]sx?$/
 
 /**
  * Bun fetches a tool it lacks, so its commands name the package; the others run the repository's own binaries.
  * Biome runs as `bunx @biomejs/biome <command>`: its package's only binary, started without naming it twice.
  */
-const DERIVED_COMMANDS: Record<PackageManager, DerivedCommands> = {
+const NODE_COMMANDS = {
   bun: {
     test: 'bun test',
     typecheck: 'bunx -p typescript tsc --noEmit',
@@ -86,16 +111,115 @@ const DERIVED_COMMANDS: Record<PackageManager, DerivedCommands> = {
     dev: 'npm run dev',
     lintFiles: 'npx @biomejs/biome check --no-errors-on-unmatched',
   },
+} satisfies Record<Exclude<Stack, 'composer'>, DerivedCommands>
+
+const firstTool = (choice: ToolChoice, manifestPackages: readonly string[]): string | undefined =>
+  choice.find(([packageName]) => manifestPackages.includes(packageName))?.[1]
+
+const COMPOSER_TOOLS = {
+  test: [
+    ['pestphp/pest', 'vendor/bin/pest'],
+    ['phpunit/phpunit', 'vendor/bin/phpunit'],
+  ],
+  typecheck: [
+    ['phpstan/phpstan', 'vendor/bin/phpstan analyse --no-progress'],
+    ['vimeo/psalm', 'vendor/bin/psalm --no-progress'],
+  ],
+  lint: [
+    ['laravel/pint', 'vendor/bin/pint --test'],
+    ['friendsofphp/php-cs-fixer', 'vendor/bin/php-cs-fixer check'],
+  ],
+  format: [
+    ['laravel/pint', 'vendor/bin/pint'],
+    ['friendsofphp/php-cs-fixer', 'vendor/bin/php-cs-fixer fix'],
+  ],
+  lintFiles: [
+    ['laravel/pint', 'vendor/bin/pint --test'],
+    ['friendsofphp/php-cs-fixer', 'vendor/bin/php-cs-fixer check --path-mode=intersection'],
+  ],
+} satisfies Partial<Record<keyof DerivedCommands, ToolChoice>>
+
+const COMPOSER_MANIFEST_SECTIONS = ['require', 'require-dev'] as const
+
+const packageNamesOf = (manifest: unknown, section: string): string[] => {
+  const packages =
+    typeof manifest === 'object' && manifest !== null ? (manifest as Record<string, unknown>)[section] : null
+  return typeof packages === 'object' && packages !== null && !Array.isArray(packages) ? Object.keys(packages) : []
 }
 
-/** The install command of each manager that stops at the lock file instead of changing it. */
-const FROZEN_INSTALL: Record<string, string> = {
-  [DERIVED_COMMANDS.bun.install]: 'bun install --frozen-lockfile',
-  [DERIVED_COMMANDS.yarn.install]: 'yarn install --immutable',
-  [DERIVED_COMMANDS.pnpm.install]: 'pnpm install --frozen-lockfile',
-  [DERIVED_COMMANDS.npm.install]: 'npm ci',
+const composerPackages = (manifest: unknown): string[] =>
+  COMPOSER_MANIFEST_SECTIONS.flatMap((section) => packageNamesOf(manifest, section))
+
+const composerCommands = (manifestPackages: readonly string[]): Partial<DerivedCommands> => {
+  const tools = Object.fromEntries(
+    Object.entries(COMPOSER_TOOLS).map(([key, choice]) => [key, firstTool(choice, manifestPackages)]),
+  )
+  return Object.fromEntries(
+    Object.entries({ ...tools, install: 'composer install', dev: 'composer run dev' }).filter(
+      ([, command]) => command !== undefined,
+    ),
+  )
+}
+
+const nodeProfile = (
+  lockFiles: readonly string[],
+  commandWords: readonly string[],
+  commands: DerivedCommands,
+  frozenInstall: string,
+): StackProfile => ({
+  lockFiles,
+  commandWords,
+  frozenInstall,
+  rootMarker: 'package.json',
+  installsIntoNodeModules: true,
+  typeMarkers: ['tsconfig.json'],
+  testFilePattern: NODE_TEST_FILE,
+  sourceFilePattern: NODE_SOURCE_FILE,
+  lintGlobs: [],
+  commands: () => commands,
+})
+
+/** One row per stack, in the order detection reports them. */
+export const STACKS: Record<Stack, StackProfile> = {
+  bun: nodeProfile(['bun.lock', 'bun.lockb'], ['bun', 'bunx'], NODE_COMMANDS.bun, 'bun install --frozen-lockfile'),
+  yarn: nodeProfile(['yarn.lock'], ['yarn'], NODE_COMMANDS.yarn, 'yarn install --immutable'),
+  pnpm: nodeProfile(['pnpm-lock.yaml'], ['pnpm'], NODE_COMMANDS.pnpm, 'pnpm install --frozen-lockfile'),
+  npm: nodeProfile(['package-lock.json'], ['npm', 'npx'], NODE_COMMANDS.npm, 'npm ci'),
+  composer: {
+    lockFiles: ['composer.lock'],
+    commandWords: ['composer'],
+    binaryDirectory: 'vendor/bin/',
+    rootMarker: 'composer.json',
+    installsIntoNodeModules: false,
+    typeMarkers: ['phpstan.neon', 'phpstan.neon.dist', 'phpstan.dist.neon', 'psalm.xml'],
+    testFilePattern: /Test\.php$/,
+    sourceFilePattern: /\.php$/,
+    lintGlobs: ['**/*.php'],
+    commands: composerCommands,
+    manifestPackages: composerPackages,
+  },
 }
 
+const STACK_NAMES = Object.keys(STACKS) as Stack[]
+
+/** The stack whose tool a command starts with (`bunx`, `composer`, `vendor/bin/pest`); undefined for a command of the project's own. */
+export const stackOfCommand = (command: string): Stack | undefined => {
+  const [word = ''] = command.trim().split(/\s+/)
+  return STACK_NAMES.find(
+    (stack) =>
+      STACKS[stack].commandWords.includes(word) ||
+      (STACKS[stack].binaryDirectory !== undefined && word.startsWith(STACKS[stack].binaryDirectory)),
+  )
+}
+
+/** The install command of each manager that stops at the lock file instead of changing it; Composer's already does. */
+const FROZEN_INSTALL: Record<string, string> = Object.fromEntries(
+  Object.values(STACKS).flatMap(({ commands, frozenInstall }) => {
+    const install = commands([]).install
+    return install === undefined || frozenInstall === undefined ? [] : [[install, frozenInstall]]
+  }),
+)
+
 /**
  * The check that a worktree's dependencies are all there: the manager's install with the lock file frozen, fast when
  * nothing is missing, fetching what is, failing when the lock file and `package.json` disagree. An install command the
@@ -103,35 +227,51 @@ const FROZEN_INSTALL: Record<string, string> = {
  */
 export const frozenInstallCommand = (install: string): string => FROZEN_INSTALL[install] ?? install
 
-/** The bun defaults of the schema, so a repository Bun runs and one detection skips agree. */
-export const BUN_COMMANDS = DERIVED_COMMANDS.bun
-
-type ConfigObject = Record<string, unknown>
-
-/** The blocks of a config that detection fills. */
-type ConfigParts = { commands: ConfigObject; lanes: ConfigObject; check: ConfigObject | undefined }
-
 const isObject = (value: unknown): value is ConfigObject =>
   typeof value === 'object' && value !== null && !Array.isArray(value)
 
 const has = (object: ConfigObject, key: string): boolean => Object.hasOwn(object, key)
 
-export const detectPackageManager = (lockFiles: readonly string[]): PackageManagerDetection => {
-  const known = Object.keys(LOCK_FILES).filter((file) => lockFiles.includes(file))
-  const managers = new Set(known.map((file) => LOCK_FILES[file]))
-  if (managers.size === 0) return { kind: 'none' }
-  if (managers.size > 1) return { kind: 'ambiguous', lockFiles: known }
-  return { kind: 'found', manager: LOCK_FILES[known[0]], lockFile: known[0] }
+/** Without a lock file, the stack whose manifest is the only one there and is no other stack's; none where managers share it. */
+const detectByManifest = (manifests: readonly string[]): StackDetection => {
+  const stacks = STACK_NAMES.filter((stack) => manifests.includes(STACKS[stack].rootMarker))
+  return stacks.length === 1
+    ? { kind: 'manifest', stack: stacks[0], manifest: STACKS[stacks[0]].rootMarker }
+    : { kind: 'none' }
+}
+
+/** The stack by its lock files; only without any lock file by its manifest, which never names a manager it shares. */
+export const detectStack = (lockFiles: readonly string[], manifests: readonly string[]): StackDetection => {
+  const known = STACK_NAMES.flatMap((stack) => STACKS[stack].lockFiles.filter((file) => lockFiles.includes(file)))
+  const stacks = new Set(STACK_NAMES.filter((stack) => STACKS[stack].lockFiles.some((file) => known.includes(file))))
+  if (stacks.size === 0) return detectByManifest(manifests)
+  if (stacks.size > 1) return { kind: 'ambiguous', lockFiles: known }
+  return { kind: 'found', stack: [...stacks][0], lockFile: known[0] }
 }
 
+/** The base branches detection chooses between; any other base is set in the config. */
+const BASE_BRANCH_CANDIDATES = ['main', 'master'] as const
+
 /** `main` or `master` when origin has exactly one of them; `origin/HEAD` is not asked, since it can point at a branch long deleted. */
 export const detectBaseBranch = (remoteBranches: readonly string[]): string | null => {
   const present = BASE_BRANCH_CANDIDATES.filter((branch) => remoteBranches.includes(branch))
   return present.length === 1 ? present[0] : null
 }
 
+const UNSET_VALUES = `\`commands\`, \`lanes.lockFile\` and \`check.lintFilesCommand\` in ${PROJECT_CONFIG_PATH}`
+
 const ambiguousNote = (lockFiles: readonly string[]): string =>
-  `${CLI_NAME}: lock files of several package managers (${lockFiles.join(', ')}); using the bun defaults. Set \`commands\` and \`lanes.lockFile\` in ${PROJECT_CONFIG_PATH}.`
+  `${CLI_NAME}: lock files of several stacks (${lockFiles.join(', ')}). Set ${UNSET_VALUES}.`
+
+/** What manifests without a lock file fail to name: one shared by several managers, or several stacks at once. */
+const unnamedBy = (manifests: readonly string[]): string =>
+  manifests.length === 1 ? 'package manager' : 'single stack'
+
+/** Without a stack: either nothing known is there, or only manifests that name no single stack. */
+const unknownStackNote = (manifests: readonly string[]): string =>
+  manifests.length === 0
+    ? `${CLI_NAME}: no known stack (lock file) in this repository; set ${UNSET_VALUES}.`
+    : `${CLI_NAME}: ${manifests.join(', ')} without a lock file names no ${unnamedBy(manifests)}; set ${UNSET_VALUES}.`
 
 const baseBranchNote = (remoteBranches: readonly string[]): string => {
   const reason = BASE_BRANCH_CANDIDATES.every((branch) => remoteBranches.includes(branch))
@@ -140,40 +280,67 @@ const baseBranchNote = (remoteBranches: readonly string[]): string => {
   return `${CLI_NAME}: ${reason}; using ${DEFAULT_BASE_BRANCH}. Set \`baseBranch\` in ${PROJECT_CONFIG_PATH}.`
 }
 
-const missingCommandKeys = (commands: ConfigObject): string[] => COMMAND_KEYS.filter((key) => !has(commands, key))
+/** What the stack of a repository sets for the values a config leaves out; empty where no stack is found. */
+export type DetectedValues = {
+  commands: Partial<Record<CommandKey, string>>
+  lanes: { lockFile?: string }
+  check: { lintFilesCommand?: string }
+}
+
+/** A stack found by its manifest alone sets no `lanes.lockFile`: the lock file does not exist yet. */
+const detectedValuesOf = (detection: StackDetection, manifestPackages: readonly string[]): DetectedValues => {
+  if (!isDecided(detection)) return { commands: {}, lanes: {}, check: {} }
+  const { lintFiles, ...derived } = STACKS[detection.stack].commands(manifestPackages)
+  const commands = Object.fromEntries(
+    COMMAND_KEYS.flatMap((key) => (derived[key] === undefined ? [] : [[key, derived[key]]])),
+  )
+  return {
+    commands,
+    lanes: detection.kind === 'found' ? { lockFile: detection.lockFile } : {},
+    check: lintFiles === undefined ? {} : { lintFilesCommand: lintFiles },
+  }
+}
 
-const withManager = (
-  raw: ConfigObject,
-  parts: ConfigParts,
-  found: { manager: PackageManager; lockFile: string },
-): ConfigObject => {
-  const derived = DERIVED_COMMANDS[found.manager]
+/** The values the repository's stack (from its lock file or manifest) would set in a config. */
+export const detectedValues = (facts: RepositoryFacts): DetectedValues =>
+  detectedValuesOf(detectStack(facts.lockFiles, facts.manifests), facts.manifestPackages)
+
+const missingCommandKeys = (commands: ConfigObject): CommandKey[] => COMMAND_KEYS.filter((key) => !has(commands, key))
+
+const withStack = (raw: ConfigObject, parts: ConfigParts, detected: DetectedValues): ConfigObject => {
   const commands = Object.fromEntries(
-    missingCommandKeys(parts.commands).map((key) => [key, derived[key as keyof DerivedCommands]]),
+    missingCommandKeys(parts.commands).flatMap((key) => {
+      const command = detected.commands[key]
+      return command === undefined ? [] : [[key, command]]
+    }),
   )
-  const check = parts.check ?? {}
   return {
     ...raw,
     commands: { ...commands, ...parts.commands },
-    lanes: { lockFile: found.lockFile, ...parts.lanes },
-    check: { lintFilesCommand: derived.lintFiles, ...check },
+    lanes: { ...detected.lanes, ...parts.lanes },
+    check: { ...detected.check, ...parts.check },
   }
 }
 
-const needsManager = (parts: ConfigParts) =>
+const needsStack = (parts: ConfigParts) =>
   missingCommandKeys(parts.commands).length > 0 ||
   !has(parts.lanes, 'lockFile') ||
   !(parts.check && has(parts.check, 'lintFilesCommand'))
 
-const fillManager = (
+const fillStack = (
   raw: ConfigObject,
   parts: ConfigParts,
-  lockFiles: readonly string[],
+  facts: RepositoryFacts,
 ): { raw: ConfigObject; notes: string[] } => {
-  if (!needsManager(parts)) return { raw, notes: [] }
-  const detection = detectPackageManager(lockFiles)
-  if (detection.kind === 'found') return { raw: withManager(raw, parts, detection), notes: [] }
-  return { raw, notes: detection.kind === 'ambiguous' ? [ambiguousNote(detection.lockFiles)] : [] }
+  if (!needsStack(parts)) return { raw, notes: [] }
+  const detection = detectStack(facts.lockFiles, facts.manifests)
+  if (isDecided(detection)) {
+    return { raw: withStack(raw, parts, detectedValuesOf(detection, facts.manifestPackages)), notes: [] }
+  }
+  return {
+    raw,
+    notes: [detection.kind === 'ambiguous' ? ambiguousNote(detection.lockFiles) : unknownStackNote(facts.manifests)],
+  }
 }
 
 const fillBaseBranch = (
@@ -196,16 +363,17 @@ const configParts = (raw: ConfigObject): ConfigParts | null => {
 
 /**
  * The raw config with every value it leaves out of `commands`, `lanes.lockFile`, `check.lintFilesCommand` and
- * `baseBranch` filled from the repository: the package manager from the lock file, the base branch from origin.
- * A value the config sets always wins. Where the repository does not decide (lock files of several managers,
- * both or neither of `main` and `master`), the schema default holds and a note says so; without a lock file the
- * defaults hold silently. A config of the wrong shape is passed through untouched for the schema to refuse.
+ * `baseBranch` filled from the repository: the stack from the lock file (without one, from a manifest only one stack
+ * has), the base branch from origin. A value the config sets always wins, and a command the stack has no tool for
+ * stays out. Where the repository does not decide (no lock file and no such manifest, lock files of several stacks,
+ * both or neither of `main` and `master`) nothing is guessed and a note
+ * says so. A config of the wrong shape is passed through untouched for the schema to refuse.
  */
 export const withDetected = (raw: unknown, facts: RepositoryFacts): { raw: unknown; notes: string[] } => {
   if (!isObject(raw)) return { raw, notes: [] }
   const parts = configParts(raw)
   if (!parts) return { raw, notes: [] }
-  const manager = fillManager(raw, parts, facts.lockFiles)
-  const base = fillBaseBranch(manager.raw, facts.remoteBranches)
-  return { raw: base.raw, notes: [...manager.notes, ...base.notes] }
+  const stack = fillStack(raw, parts, facts)
+  const base = fillBaseBranch(stack.raw, facts.remoteBranches)
+  return { raw: base.raw, notes: [...stack.notes, ...base.notes] }
 }

package/src/config/location.ts

@@ -12,6 +12,12 @@ export const CONFIG_SCHEMA_REFERENCE = `../node_modules/${PACKAGE_NAME}/schemas/
 /** The project's config, relative to its root; the same path below the home directory is the global config. */
 export const PROJECT_CONFIG_PATH = `${TOOL_DIRECTORY}/${CONFIG_FILE}`
 
+/**
+ * What stands in for a value the project config leaves unset, such as `commands.test`: where to set it. Plain text
+ * without backticks, since a kit text puts the value inside a code span.
+ */
+export const unsetValueText = (key: string): string => `not set: ${key} in ${PROJECT_CONFIG_PATH}`
+
 /** Where the config lay before 0.29, read until 2.0.0 when the new one is missing; never written. */
 export const LEGACY_CONFIG_PATH = '.claude/agent-kit.json'
 

package/src/config/repository-facts.ts

@@ -1,7 +1,7 @@
 import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { LOCK_FILES, type RepositoryFacts } from './detect'
+import { detectStack, isDecided, type RepositoryFacts, STACKS } from './detect'
 
 const REMOTE_BRANCHES = ['for-each-ref', '--format=%(refname:lstrip=3)', 'refs/remotes/origin/']
 
@@ -12,8 +12,33 @@ const remoteBranchesOf = (root: string): string[] => {
   return result.stdout.split('\n').filter((branch) => branch !== '' && branch !== 'HEAD')
 }
 
-/** The lock files and origin branches of the repository at `root`; reads only, never fetches. */
-export const readRepositoryFacts = (root: string): RepositoryFacts => ({
-  lockFiles: Object.keys(LOCK_FILES).filter((file) => existsSync(join(root, file))),
-  remoteBranches: remoteBranchesOf(root),
-})
+const readJson = (path: string): unknown => {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/** Package names the root manifest of the detected stack declares; none without one stack, or for a missing or broken manifest. */
+const manifestPackagesOf = (root: string, lockFiles: readonly string[], manifests: readonly string[]): string[] => {
+  const detection = detectStack(lockFiles, manifests)
+  if (!isDecided(detection)) return []
+  const { rootMarker, manifestPackages } = STACKS[detection.stack]
+  return manifestPackages ? manifestPackages(readJson(join(root, rootMarker))) : []
+}
+
+/** The lock files, manifests, manifest packages and origin branches of the repository at `root`; reads only, never fetches. */
+export const readRepositoryFacts = (root: string): RepositoryFacts => {
+  const present = (file: string) => existsSync(join(root, file))
+  const lockFiles = Object.values(STACKS)
+    .flatMap((stack) => stack.lockFiles)
+    .filter(present)
+  const manifests = [...new Set(Object.values(STACKS).map((stack) => stack.rootMarker))].filter(present)
+  return {
+    lockFiles,
+    manifests,
+    manifestPackages: manifestPackagesOf(root, lockFiles, manifests),
+    remoteBranches: remoteBranchesOf(root),
+  }
+}