polyrepo-cli 1.0.0

package/src/commands/exec.js

@@ -0,0 +1,76 @@
+import { confirm } from '@inquirer/prompts'
+import pc from 'picocolors'
+import { discoverRepos, inspectRepos } from '../repos.js'
+import { loadConfig } from '../loadConfig.js'
+import { run } from '../exec.js'
+import { selectPackages } from '../selectPackages.js'
+import { heading, stepHeading, ok, fail, columnWidths, formatRow } from '../ui.js'
+
+// Runs one package at a time (not in parallel, unlike the read-only checks
+// elsewhere in this CLI) and always with a real terminal (stdio: 'inherit')
+// — the whole point is running an arbitrary command, which might itself
+// want a TTY (colored output, its own progress bar, an interactive
+// prompt), and interleaved output from several packages running the same
+// command at once would be unreadable anyway.
+export async function execCommand({ configPath, packages, yes = false, bail = false, cmd } = {}) {
+  const config = loadConfig({ configPath })
+  const repos = await inspectRepos(discoverRepos(config))
+  if (repos.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  const label = cmd.join(' ')
+  heading(`Run: ${label}`)
+
+  const selected = await selectPackages({
+    items: repos,
+    packages,
+    message: 'Pick packages to run the command in:',
+    buildChoice: (all) => {
+      const columns = [
+        { value: (r) => r.dir },
+        { value: (r) => r.version ?? '?', style: (r, t) => pc.dim(t) },
+      ]
+      const widths = columnWidths(all, columns)
+      return (r) => ({ name: formatRow(r, columns, widths), value: r, checked: true })
+    },
+  })
+
+  if (selected.length === 0) {
+    console.log(pc.dim('Nothing selected.'))
+    return
+  }
+
+  if (!yes) {
+    const proceed = await confirm({
+      message: `Run \`${label}\` in ${selected.length} package(s)?`,
+      default: true,
+    })
+    if (!proceed) {
+      console.log(pc.dim('Cancelled.'))
+      return
+    }
+  }
+
+  const failed = []
+  let index = 0
+  for (const repo of selected) {
+    index += 1
+    stepHeading(index, selected.length, repo.dir)
+    const result = run(repo.path, cmd[0], cmd.slice(1), { interactive: true })
+    if (!result.ok) {
+      failed.push(repo.dir)
+      fail(`Exited with code ${result.status}.`)
+      if (bail) break
+    } else {
+      ok('Done.')
+    }
+  }
+
+  if (failed.length > 0) {
+    console.log('')
+    console.log(pc.red(`${failed.length}/${selected.length} package(s) failed: ${failed.join(', ')}`))
+    process.exitCode = 1
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,107 @@
+import pc from 'picocolors'
+import { discoverRepos, inspectRepos } from '../repos.js'
+import { MASTER_BRANCH } from '../config.js'
+import { loadConfig } from '../loadConfig.js'
+import { tagName, tagExistsAsync } from '../tags.js'
+import { releaseExistsAsync } from '../release.js'
+import { fetchPublishedVersionAsync } from '../registry.js'
+import { findStaleLocalDeps } from '../crossDeps.js'
+import { pMap } from '../pMap.js'
+import { printTable, heading, ok, fail } from '../ui.js'
+import { startSpinner } from '../spinner.js'
+import { EXPORT_FORMATS, exportTable, inferExportFormat, writeExport } from '../export.js'
+
+export async function listCommand({ configPath, quick = false, showPath = false, format, output } = {}) {
+  if (format && !EXPORT_FORMATS.includes(format)) {
+    fail(`Unknown --format "${format}" — expected one of: ${EXPORT_FORMATS.join(', ')}.`)
+    return
+  }
+  if (format && !output) {
+    fail('--format only matters together with --output <path> — nothing to export it to.')
+    return
+  }
+
+  const config = loadConfig({ configPath })
+  const repos = discoverRepos(config)
+  if (repos.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  heading(`Packages (${repos.length})`)
+
+  const gitSpinner = startSpinner(`Checking ${repos.length} package(s) — version, branch, git status...`)
+  const rows = await inspectRepos(repos)
+  gitSpinner.stop()
+
+  const columns = [
+    { label: 'Package', value: (r) => r.dir },
+    ...(showPath ? [{ label: 'Path', value: (r) => r.path, style: (r, text) => pc.dim(text) }] : []),
+    { label: 'Version', value: (r) => r.version ?? '?' },
+    {
+      label: 'Branch',
+      value: (r) => r.branch ?? '(detached)',
+      style: (r, text) => (r.branch === MASTER_BRANCH ? pc.dim(text) : pc.yellow(text)),
+    },
+    {
+      label: 'Git',
+      value: (r) => (r.clean ? 'clean' : 'dirty'),
+      style: (r, text) => (r.clean ? pc.dim(text) : pc.red(text)),
+    },
+  ]
+
+  let finalRows = rows
+
+  if (!quick) {
+    // Cross-package dependency drift is cheap (no network — just the
+    // package.jsons already on disk) and doesn't vary per package the way
+    // tag/release/npm do, so it's computed once for everyone rather than
+    // inside the per-repo pMap below.
+    const staleByRepo = new Map()
+    for (const issue of findStaleLocalDeps(rows)) {
+      staleByRepo.set(issue.repo.dir, (staleByRepo.get(issue.repo.dir) ?? 0) + 1)
+    }
+
+    const registrySpinner = startSpinner(`Checking ${rows.length} package(s) for tags, releases, and the registry...`)
+    const withReleaseInfo = await pMap(rows, async (r) => {
+      const tag = tagName(r.version)
+      const [tagged, published] = await Promise.all([tagExistsAsync(r, tag), fetchPublishedVersionAsync(r)])
+      const released = tagged ? await releaseExistsAsync(r, tag) : false
+      return { ...r, tag, tagged, released, published, staleDeps: staleByRepo.get(r.dir) ?? 0 }
+    })
+    registrySpinner.stop()
+
+    columns.push(
+      {
+        label: 'Tag',
+        value: (r) => (r.tagged ? r.tag : '—'),
+        style: (r, text) => pc.dim(text),
+      },
+      {
+        label: 'Release',
+        value: (r) => (!r.tagged ? '—' : r.released ? '✓' : '✗'),
+        style: (r, text) => (r.released ? pc.green(text) : pc.dim(text)),
+      },
+      {
+        label: 'npm',
+        value: (r) => (r.published == null ? 'unpublished' : r.published === r.version ? '✓' : r.published),
+        style: (r, text) => (r.published === r.version ? pc.green(text) : pc.yellow(text)),
+      },
+      {
+        label: 'Deps',
+        value: (r) => (r.staleDeps > 0 ? `⚠ ${r.staleDeps}` : '✓'),
+        style: (r, text) => (r.staleDeps > 0 ? pc.yellow(text) : pc.dim(text)),
+      },
+    )
+
+    finalRows = withReleaseInfo
+  }
+
+  printTable(finalRows, columns)
+
+  if (output) {
+    const resolvedFormat = format ?? inferExportFormat(output)
+    const savedPath = writeExport(output, exportTable(finalRows, columns, resolvedFormat))
+    ok(`Saved ${resolvedFormat.toUpperCase()} to ${savedPath}.`)
+  }
+}

package/src/commands/outdated.js

@@ -0,0 +1,92 @@
+import semver from 'semver'
+import pc from 'picocolors'
+import { discoverRepos, inspectRepos } from '../repos.js'
+import { loadConfig } from '../loadConfig.js'
+import { npmAsync } from '../exec.js'
+import { pMap } from '../pMap.js'
+import { heading, printTable } from '../ui.js'
+import { startSpinner } from '../spinner.js'
+import { filterByNames } from '../filterByNames.js'
+
+// How far behind "latest" actually is — a major bump is a different kind
+// of attention than a patch, and lumping them under one color hid that.
+// premajor/preminor collapse into their stable counterpart; prepatch and
+// plain prerelease both read as "patch-level" here — none of them warrant
+// their own bucket for a dependency table. Returns null when either side
+// isn't a parseable version (current can be missing entirely for a
+// package that's declared but never installed) or they're already equal.
+function diffSeverity(current, latest) {
+  if (!current || !latest || !semver.valid(current) || !semver.valid(latest)) return null
+  const diff = semver.diff(current, latest)
+  if (!diff) return null
+  if (diff === 'major' || diff === 'premajor') return 'major'
+  if (diff === 'minor' || diff === 'preminor') return 'minor'
+  return 'patch'
+}
+
+const SEVERITY_COLOR = { major: pc.red, minor: pc.yellow, patch: pc.dim }
+
+export async function outdatedCommand({ configPath, packages } = {}) {
+  const config = loadConfig({ configPath })
+  const repos = filterByNames((await inspectRepos(discoverRepos(config))).filter((r) => r.version), packages)
+  if (repos.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  heading('Outdated dependencies')
+
+  const spinner = startSpinner(`Checking ${repos.length} package(s) for outdated dependencies...`)
+  const results = await pMap(repos, async (r) => {
+    // `npm outdated --json` exits 1 whenever it finds anything outdated —
+    // that's normal, not a failure, so "did this work" is judged by
+    // whether stdout is parseable JSON rather than the exit code.
+    const result = await npmAsync(r.path, ['outdated', '--json'])
+    if (!result.stdout) return { repo: r, entries: [], failed: !result.ok }
+    try {
+      return { repo: r, entries: Object.entries(JSON.parse(result.stdout)).map(([name, info]) => ({ name, ...info })) }
+    } catch {
+      return { repo: r, entries: [], failed: true }
+    }
+  })
+  spinner.stop()
+
+  const failedRepos = results.filter((r) => r.failed).map((r) => r.repo.dir)
+  if (failedRepos.length > 0) {
+    console.log(pc.yellow(`Could not check: ${failedRepos.join(', ')}`))
+  }
+
+  const rows = results.flatMap(({ repo, entries }) =>
+    entries.map((e) => ({
+      dir: repo.dir,
+      name: e.name,
+      current: e.current ?? '—',
+      wanted: e.wanted ?? '—',
+      latest: e.latest ?? '—',
+      severity: diffSeverity(e.current, e.latest),
+    })),
+  )
+
+  if (rows.length === 0) {
+    console.log(pc.green('Everything up to date.'))
+    return
+  }
+
+  const packageCount = new Set(rows.map((r) => r.dir)).size
+  const majorCount = rows.filter((r) => r.severity === 'major').length
+  const depWord = rows.length === 1 ? 'dependency' : 'dependencies'
+  const summary = `${rows.length} ${depWord} outdated across ${packageCount} package(s)`
+  console.log(pc.dim(summary) + (majorCount > 0 ? pc.red(`, ${majorCount} of them major version behind`) : ''))
+
+  printTable(
+    rows,
+    [
+      { label: 'Package', value: (r) => r.dir },
+      { label: 'Dependency', value: (r) => r.name },
+      { label: 'Current', value: (r) => r.current, style: (r, t) => pc.dim(t) },
+      { label: 'Wanted', value: (r) => r.wanted },
+      { label: 'Latest', value: (r) => r.latest, style: (r, t) => (SEVERITY_COLOR[r.severity] ?? pc.dim)(t) },
+    ],
+    { groupBy: (r) => r.dir },
+  )
+}

package/src/commands/prs.js

@@ -0,0 +1,65 @@
+import pc from 'picocolors'
+import { discoverRepos } from '../repos.js'
+import { loadConfig } from '../loadConfig.js'
+import { ghAsync } from '../exec.js'
+import { pMap } from '../pMap.js'
+import { heading, printTable } from '../ui.js'
+import { startSpinner } from '../spinner.js'
+import { filterByNames } from '../filterByNames.js'
+
+export async function prsCommand({ configPath, packages } = {}) {
+  const config = loadConfig({ configPath })
+  const repos = filterByNames(discoverRepos(config), packages)
+  if (repos.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  heading('Open pull requests')
+
+  const spinner = startSpinner(`Checking ${repos.length} package(s) for open pull requests...`)
+  const results = await pMap(repos, async (r) => {
+    const result = await ghAsync(r.path, [
+      'pr',
+      'list',
+      '--state',
+      'open',
+      '--json',
+      'number,title,headRefName,isDraft',
+    ])
+    if (!result.ok || !result.stdout) return { repo: r, prs: [] }
+    try {
+      return { repo: r, prs: JSON.parse(result.stdout) }
+    } catch {
+      return { repo: r, prs: [] }
+    }
+  })
+  spinner.stop()
+
+  const rows = results.flatMap(({ repo, prs }) =>
+    prs.map((pr) => ({
+      dir: repo.dir,
+      number: `#${pr.number}`,
+      title: pr.title.length > 50 ? `${pr.title.slice(0, 47)}...` : pr.title,
+      branch: pr.headRefName,
+      draft: pr.isDraft,
+    })),
+  )
+
+  if (rows.length === 0) {
+    console.log(pc.green('No open pull requests.'))
+    return
+  }
+
+  printTable(
+    rows,
+    [
+      { label: 'Package', value: (r) => r.dir },
+      { label: 'PR', value: (r) => r.number, style: (r, t) => pc.dim(t) },
+      { label: 'Title', value: (r) => r.title },
+      { label: 'Branch', value: (r) => r.branch, style: (r, t) => pc.dim(t) },
+      { label: 'Status', value: (r) => (r.draft ? 'draft' : ''), style: (r, t) => pc.yellow(t) },
+    ],
+    { groupBy: (r) => r.dir },
+  )
+}

package/src/commands/publish.js

@@ -0,0 +1,82 @@
+import { confirm } from '@inquirer/prompts'
+import pc from 'picocolors'
+import { discoverRepos, inspectRepos } from '../repos.js'
+import { loadConfig } from '../loadConfig.js'
+import { npm } from '../exec.js'
+import { fetchPublishedVersionAsync } from '../registry.js'
+import { selectPackages } from '../selectPackages.js'
+import { pMap } from '../pMap.js'
+import { heading, stepHeading, ok, fail, columnWidths, formatRow } from '../ui.js'
+
+export async function publishCommand({ configPath, packages, yes = false, dryRun = false } = {}) {
+  const config = loadConfig({ configPath })
+  const repos = (await inspectRepos(discoverRepos(config))).filter((r) => r.version)
+  if (repos.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  heading('Publish to npm')
+
+  console.log(pc.dim(`Checking ${repos.length} package(s) against the registry...`))
+  // Each repo's registry lookup is a real network round trip — running them
+  // all at once instead of one at a time is where this actually pays off.
+  // Printed as each one resolves, so the order below reflects how fast the
+  // registry answered, not the package list's order.
+  const withRegistry = await pMap(repos, async (r) => {
+    const published = await fetchPublishedVersionAsync(r)
+    const needsPublish = published !== r.version
+    console.log(
+      pc.dim(`  ${r.dir}: registry ${published ?? '(not published)'} ${needsPublish ? '≠' : '='} local ${r.version}`),
+    )
+    return { ...r, published, needsPublish }
+  })
+
+  const selected = await selectPackages({
+    items: withRegistry,
+    packages,
+    message: 'Pick packages to publish:',
+    buildChoice: (all) => {
+      const columns = [
+        { value: (r) => r.dir },
+        { value: (r) => r.published ?? '(none)', style: (r, t) => pc.dim(t) },
+        { value: () => '→', style: (r, t) => pc.dim(t) },
+        { value: (r) => r.version, style: (r, t) => (r.needsPublish ? pc.green(t) : pc.dim(t)) },
+      ]
+      const widths = columnWidths(all, columns)
+      return (r) => ({
+        name: formatRow(r, columns, widths) + (r.needsPublish ? '' : pc.dim('  (already up to date)')),
+        value: r,
+        checked: r.needsPublish,
+      })
+    },
+  })
+
+  if (selected.length === 0) {
+    console.log(pc.dim('Nothing selected.'))
+    return
+  }
+
+  if (!yes) {
+    const proceed = await confirm({
+      message: `Publish ${selected.length} package(s) to npm?${dryRun ? ' (dry run — nothing will actually be published)' : ''}`,
+      default: true,
+    })
+    if (!proceed) {
+      console.log(pc.dim('Cancelled.'))
+      return
+    }
+  }
+
+  let index = 0
+  for (const repo of selected) {
+    index += 1
+    stepHeading(index, selected.length, `${repo.name}@${repo.version}`)
+    // Real terminal, not captured — npm publish can stop for a 2FA/OTP
+    // prompt, and --dry-run (npm's own flag) does a full dry run including
+    // packing, so this exercises the same path as a real publish.
+    const result = npm(repo.path, ['publish', ...(dryRun ? ['--dry-run'] : [])], { interactive: true })
+    if (!result.ok) fail(`npm publish failed (exit ${result.status}).`)
+    else ok(`Published ${repo.name}@${repo.version}${dryRun ? ' (dry run).' : '.'}`)
+  }
+}

package/src/commands/release.js

@@ -0,0 +1,121 @@
+import { confirm } from '@inquirer/prompts'
+import pc from 'picocolors'
+import { discoverRepos, inspectRepos } from '../repos.js'
+import { loadConfig } from '../loadConfig.js'
+import { tagName, tagExists } from '../tags.js'
+import { releaseExistsAsync, createRelease } from '../release.js'
+import { extractChangelogSection } from '../changelog.js'
+import { selectPackages } from '../selectPackages.js'
+import { pMap } from '../pMap.js'
+import { heading, stepHeading, ok, fail, columnWidths, formatRow } from '../ui.js'
+
+export async function releaseCommand({ configPath, packages, yes = false, dryRun = false } = {}) {
+  const config = loadConfig({ configPath })
+  const repos = (await inspectRepos(discoverRepos(config))).filter((r) => r.version)
+  if (repos.length === 0) {
+    console.log(pc.yellow('No repos found.'))
+    return
+  }
+
+  heading('GitHub releases')
+
+  console.log(pc.dim(`Checking ${repos.length} package(s) for a tag and an existing release...`))
+  // A release always targets `v<local version>` — the tag `polyrepo bump`
+  // creates. No tag for the current version means there's nothing to
+  // release yet; a tag with no release is exactly what this command is for.
+  const withStatus = await pMap(repos, async (r) => {
+    const tag = tagName(r.version)
+    const tagged = tagExists(r, tag)
+    const released = tagged ? await releaseExistsAsync(r, tag) : false
+    const status = !tagged ? 'no-tag' : released ? 'released' : 'ready'
+    const statusText = status === 'no-tag' ? 'not tagged yet' : status === 'released' ? 'already released' : 'ready'
+    console.log(pc.dim(`  ${r.dir}: ${tag} — ${statusText}`))
+    return { ...r, tag, status }
+  })
+
+  // Every choice would be disabled ("no tag yet") — @inquirer/checkbox
+  // throws rather than just showing an empty list in that case, so this
+  // needs to be caught before ever calling selectPackages when the
+  // checkbox is actually going to render (a --packages run doesn't hit
+  // this, since it skips the checkbox and the per-repo loop below already
+  // reports "no tag" per package on its own).
+  if (!packages && withStatus.every((r) => r.status === 'no-tag')) {
+    console.log(
+      pc.yellow('No packages are tagged yet — run `polyrepo bump` (new version) or `polyrepo tag` (current version) first.'),
+    )
+    return
+  }
+
+  const selected = await selectPackages({
+    items: withStatus,
+    packages,
+    message: 'Pick packages to create a GitHub Release for:',
+    buildChoice: (all) => {
+      const columns = [
+        { value: (r) => r.dir },
+        { value: (r) => r.tag, style: (r, t) => pc.dim(t) },
+      ]
+      const widths = columnWidths(all, columns)
+      return (r) => ({
+        name: formatRow(r, columns, widths) + statusSuffix(r),
+        value: r,
+        checked: r.status === 'ready',
+        disabled: r.status === 'no-tag' ? '(no tag yet — run `polyrepo bump` or `polyrepo tag` first)' : false,
+      })
+    },
+  })
+
+  if (selected.length === 0) {
+    console.log(pc.dim('Nothing selected.'))
+    return
+  }
+
+  if (!yes) {
+    const proceed = await confirm({
+      message: `Create ${selected.length} GitHub Release(s)?${dryRun ? ' (dry run — nothing will actually be created)' : ''}`,
+      default: true,
+    })
+    if (!proceed) {
+      console.log(pc.dim('Cancelled.'))
+      return
+    }
+  }
+
+  let index = 0
+  for (const repo of selected) {
+    index += 1
+    stepHeading(index, selected.length, `${repo.dir}  ${repo.tag}`)
+
+    // The checkbox disables "no-tag" choices so they can't be picked
+    // interactively, but --packages bypasses the checkbox entirely — this
+    // is the guard for that path (and cheap insurance against the status
+    // having gone stale between the check above and here).
+    if (repo.status === 'no-tag') {
+      fail(`No tag ${repo.tag} on origin — run \`polyrepo bump\` or \`polyrepo tag\` first.`)
+      continue
+    }
+
+    releaseOne(repo, repo.tag, { dryRun })
+  }
+}
+
+// Also used by `polyrepo tag` to offer "release what I just tagged" right after
+// tagging, without making that command build its own checkbox/confirm and
+// re-discover which packages are release-ready — it already knows exactly.
+export function releaseOne(repo, tag, { dryRun } = {}) {
+  const notes = extractChangelogSection(repo, repo.version)
+  const title = `${repo.name}@${repo.version}`
+  ok(notes ? 'Using the matching CHANGELOG.md section as release notes.' : 'No changelog entry — using --generate-notes.')
+
+  const result = createRelease(repo, { tag, title, notes, dryRun })
+  if (!result.ok) fail(`gh release create failed (exit ${result.status}).`)
+  else ok(`Created release ${title}.`)
+}
+
+// @inquirer/checkbox appends the `disabled` reason after the name itself
+// for disabled choices, so "no-tag" needs nothing here — only "released"
+// needs an explicit suffix, since it stays selectable (re-releasing is a
+// legitimate thing to want) but shouldn't look identical to a fresh one.
+function statusSuffix(r) {
+  return r.status === 'released' ? pc.dim('  (already released)') : ''
+}

package/src/commands/setup.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs'
+import { select, input, confirm, Separator } from '@inquirer/prompts'
+import pc from 'picocolors'
+import { resolveConfigFilePath, readConfigFile, writeConfigFile } from '../configFile.js'
+import { isRepo } from '../repos.js'
+import { heading, ok, warn, promptTheme } from '../ui.js'
+
+export async function setupCommand({ configPath } = {}) {
+  const filePath = resolveConfigFilePath(configPath)
+  const data = readConfigFile(filePath)
+  let dirty = false
+
+  heading('Configure package sources')
+  console.log(pc.dim(`Editing: ${filePath}`))
+
+  while (true) {
+    console.log('')
+    printEntries('roots (subfolders are scanned as packages)', data.roots, describeRoot)
+    console.log('')
+    printEntries('packages (the folder itself is the package)', data.packages, describePackage)
+
+    const choices = [
+      { name: 'Add a root directory', value: 'add-root' },
+      { name: 'Add a single package directory', value: 'add-package' },
+    ]
+    if (data.roots.length + data.packages.length > 0) {
+      choices.push(
+        { name: 'Edit an entry', value: 'edit' },
+        { name: 'Remove an entry', value: 'remove' },
+      )
+    }
+    choices.push(new Separator())
+    choices.push({ name: dirty ? 'Save and exit' : 'Exit', value: 'exit' })
+    if (dirty) choices.push({ name: 'Discard changes and exit', value: 'discard' })
+
+    console.log('')
+    const action = await select({ message: 'What do you want to do?', choices, theme: promptTheme })
+
+    if (action === 'add-root') {
+      const value = await promptPath('Root directory (its direct subfolders are scanned as packages):')
+      if (value) {
+        data.roots.push(value)
+        dirty = true
+      }
+    } else if (action === 'add-package') {
+      const value = await promptPath('Package directory (this folder itself is the package):')
+      if (value) {
+        data.packages.push(value)
+        dirty = true
+      }
+    } else if (action === 'edit') {
+      const picked = await pickEntry(data)
+      if (picked) {
+        const current = data[picked.kind][picked.index]
+        const label = picked.kind === 'roots' ? 'root' : 'package directory'
+        const value = await promptPath(`New value for this ${label}:`, current)
+        if (value) {
+          data[picked.kind][picked.index] = value
+          dirty = true
+        }
+      }
+    } else if (action === 'remove') {
+      const picked = await pickEntry(data)
+      if (picked) {
+        const current = data[picked.kind][picked.index]
+        const reallyRemove = await confirm({ message: `Remove "${current}"?`, default: false })
+        if (reallyRemove) {
+          data[picked.kind].splice(picked.index, 1)
+          dirty = true
+        }
+      }
+    } else if (action === 'exit') {
+      if (dirty) {
+        writeConfigFile(filePath, data)
+        ok(`Saved ${filePath}`)
+      }
+      return
+    } else if (action === 'discard') {
+      console.log(pc.dim('Discarded changes.'))
+      return
+    }
+  }
+}
+
+function printEntries(label, list, describe) {
+  console.log(pc.bold(label))
+  if (list.length === 0) {
+    console.log(pc.dim('  (none)'))
+    return
+  }
+  list.forEach((p, i) => console.log(`  ${i + 1}. ${describe(p)}`))
+}
+
+function describeRoot(p) {
+  return `${p}  ${fs.existsSync(p) ? pc.green('✓ exists') : pc.red('✗ not found')}`
+}
+
+function describePackage(p) {
+  if (!fs.existsSync(p)) return `${p}  ${pc.red('✗ not found')}`
+  if (!isRepo(p)) return `${p}  ${pc.yellow('! no package.json/.git here')}`
+  return `${p}  ${pc.green('✓ ok')}`
+}
+
+async function promptPath(message, defaultValue) {
+  const value = await input({ message, default: defaultValue })
+  const trimmed = value.trim()
+  if (!trimmed) return null
+  if (!fs.existsSync(trimmed)) {
+    warn(`Path does not exist yet — added anyway: ${trimmed}`)
+  }
+  return trimmed
+}
+
+async function pickEntry(data) {
+  const choices = [
+    ...data.roots.map((p, i) => ({ name: `[root] ${p}`, value: { kind: 'roots', index: i } })),
+    ...data.packages.map((p, i) => ({ name: `[package] ${p}`, value: { kind: 'packages', index: i } })),
+    { name: 'Cancel', value: null },
+  ]
+  return select({ message: 'Which entry?', choices, theme: promptTheme })
+}