polyrepo-cli 1.0.0

package/src/repos.js

@@ -0,0 +1,114 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import pc from 'picocolors'
+import { gitAsync } from './exec.js'
+import { pMap } from './pMap.js'
+
+export function isRepo(dirPath) {
+  return fs.existsSync(path.join(dirPath, 'package.json')) && fs.existsSync(path.join(dirPath, '.git'))
+}
+
+function toEntry(dirPath) {
+  return {
+    dir: path.basename(dirPath),
+    path: dirPath,
+    pkgPath: path.join(dirPath, 'package.json'),
+  }
+}
+
+// `config.roots` — folders whose direct subdirectories are packages (the
+// original C:\work\NPM-style layout). `config.packages` — individual
+// package folders given directly, for a one-off repo that doesn't live
+// under any of the scanned roots. A folder missing package.json/.git is
+// silently skipped when found via a root scan (e.g. vue-masonry-kit, which
+// has only README/LICENSE so far) but reported when named explicitly in
+// `packages`, since that's almost certainly a typo worth knowing about.
+export function discoverRepos(config) {
+  const repos = []
+  const seen = new Set()
+
+  for (const root of config.roots) {
+    if (!fs.existsSync(root)) {
+      console.log(pc.yellow(`Configured root does not exist, skipping: ${root}`))
+      continue
+    }
+    const entries = fs.readdirSync(root, { withFileTypes: true })
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const repoPath = path.join(root, entry.name)
+      if (!isRepo(repoPath)) continue
+      addRepo(repoPath)
+    }
+  }
+
+  for (const pkgDir of config.packages) {
+    if (!fs.existsSync(pkgDir)) {
+      console.log(pc.yellow(`Configured package folder does not exist, skipping: ${pkgDir}`))
+      continue
+    }
+    if (!isRepo(pkgDir)) {
+      console.log(pc.yellow(`Configured package folder has no package.json/.git, skipping: ${pkgDir}`))
+      continue
+    }
+    addRepo(pkgDir)
+  }
+
+  function addRepo(repoPath) {
+    const key = path.resolve(repoPath).toLowerCase()
+    if (seen.has(key)) return
+    seen.add(key)
+    repos.push(toEntry(repoPath))
+  }
+
+  repos.sort((a, b) => a.dir.localeCompare(b.dir))
+  return repos
+}
+
+export function readPackageJson(repo) {
+  const text = fs.readFileSync(repo.pkgPath, 'utf8')
+  const nameMatch = text.match(/"name"\s*:\s*"([^"]+)"/)
+  const versionMatch = text.match(/"version"\s*:\s*"([^"]+)"/)
+  return {
+    text,
+    name: nameMatch ? nameMatch[1] : repo.dir,
+    version: versionMatch ? versionMatch[1] : null,
+  }
+}
+
+// Full snapshot used everywhere a package list is shown: name, version,
+// current branch, and whether the working tree has uncommitted changes.
+// The two git calls per repo run concurrently across repos (see pMap)
+// instead of one repo waiting on the last.
+export async function inspectRepoAsync(repo) {
+  const pkg = readPackageJson(repo)
+  const [branchResult, statusResult] = await Promise.all([
+    gitAsync(repo.path, ['branch', '--show-current']),
+    gitAsync(repo.path, ['status', '--porcelain']),
+  ])
+  const branch = branchResult.ok ? branchResult.stdout || null : null
+  const clean = statusResult.ok && statusResult.stdout === ''
+  return { ...repo, ...pkg, branch, clean }
+}
+
+export function inspectRepos(repos, concurrency) {
+  return pMap(repos, inspectRepoAsync, concurrency)
+}
+
+// Raw dependency ranges declared by a package — used to cross-check whether
+// one local package still points at a stale version of another local one
+// after a bump. Parses the real JSON (unlike readPackageJson's regex-based
+// extraction, which only needs name/version and deliberately avoids
+// reformatting the file on write) since dependency objects are more than a
+// single scalar to pull out reliably with a regex.
+export function readPackageDependencies(repo) {
+  try {
+    const json = JSON.parse(fs.readFileSync(repo.pkgPath, 'utf8'))
+    return {
+      ...json.dependencies,
+      ...json.devDependencies,
+      ...json.peerDependencies,
+    }
+  } catch {
+    return {}
+  }
+}

package/src/selectPackages.js

@@ -0,0 +1,38 @@
+import { checkbox } from '@inquirer/prompts'
+import pc from 'picocolors'
+import { promptTheme } from './ui.js'
+import { filterByNames } from './filterByNames.js'
+
+// Shared "pick some packages" step used by both `bump` and `publish`:
+// either takes an explicit --packages list (skips the prompt entirely,
+// warning about any name that doesn't match a discovered package) or shows
+// an aligned-column checkbox. `buildChoice` receives the full item list
+// (so column widths can be computed across all of them) and must return a
+// per-item `(item) => choice` function.
+export async function selectPackages({ items, packages, message, buildChoice, pageSize = 20 }) {
+  if (packages) {
+    return filterByNames(items, packages)
+  }
+
+  const makeChoice = buildChoice(items)
+  const choices = items.map(makeChoice)
+
+  // @inquirer/checkbox throws (not rejects — a synchronous throw, so the
+  // top-level ExitPromptError handler in index.js never sees it) if every
+  // choice is disabled — e.g. `polyrepo release` before anything has been
+  // tagged yet. Callers that use `disabled` should really check for this
+  // themselves with a message specific to why (see release.js), but this
+  // is the backstop so a command that doesn't ends in a clean message
+  // instead of a raw ValidationError stack trace.
+  if (choices.length > 0 && choices.every((c) => c.disabled)) {
+    console.log(pc.yellow('Nothing selectable — every item is disabled.'))
+    return []
+  }
+
+  return checkbox({
+    message,
+    pageSize,
+    theme: promptTheme,
+    choices,
+  })
+}

package/src/spinner.js

@@ -0,0 +1,38 @@
+import pc from 'picocolors'
+
+// Classic braille "dots" spinner (⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏) — same frames @inquirer/core
+// uses by default for its own prompts. Visually a 2-column, 3-row dot grid
+// with one dot missing at a time, circling around.
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+const INTERVAL_MS = 80
+const CLEAR_LINE = '\r\x1b[K'
+
+// Covers the "nothing is printed for several seconds" gap while a parallel
+// batch (pMap) is in flight and there's no per-item progress to show yet —
+// list's full mode, doctor, and the initial repo scan in bump/switch-master
+// all used to just sit there silently. Falls back to a single static line
+// when stdout isn't a real terminal (piped output, CI logs) — redrawing
+// with carriage returns there would just dump a stream of raw \r bytes
+// instead of animating.
+export function startSpinner(message) {
+  if (!process.stdout.isTTY) {
+    console.log(pc.dim(message))
+    return { stop() {} }
+  }
+
+  let frame = 0
+  process.stdout.write(`${pc.yellow(FRAMES[0])} ${message}`)
+  const timer = setInterval(() => {
+    frame = (frame + 1) % FRAMES.length
+    process.stdout.write(`\r${pc.yellow(FRAMES[frame])} ${message}`)
+  }, INTERVAL_MS)
+
+  return {
+    stop() {
+      clearInterval(timer)
+      // Full line clear (not just enough spaces to cover the old text) —
+      // the final line's shape doesn't have to match the spinner line's.
+      process.stdout.write(`${CLEAR_LINE}${pc.dim(message)}\n`)
+    },
+  }
+}

package/src/tags.js

@@ -0,0 +1,30 @@
+import { git, gitAsync } from './exec.js'
+
+export function tagName(version) {
+  return `v${version}`
+}
+
+export function tagExists(repo, tag) {
+  // Checks the remote, not just the local repo — the source of truth for
+  // "was this version already released" is origin, and a fresh clone
+  // wouldn't have any tags fetched locally yet.
+  const result = git(repo.path, ['ls-remote', '--exit-code', '--tags', 'origin', tag], { quiet: true })
+  return result.ok
+}
+
+// Same check, used where many repos are checked at once (see pMap) —
+// `polyrepo tag`'s package list, for one.
+export async function tagExistsAsync(repo, tag) {
+  const result = await gitAsync(repo.path, ['ls-remote', '--exit-code', '--tags', 'origin', tag])
+  return result.ok
+}
+
+export function createAndPushTag(repo, tag, { dryRun } = {}) {
+  if (!git(repo.path, ['tag', '-a', tag, '-m', tag], { mutating: true, dryRun }).ok) {
+    return { ok: false, message: `git tag ${tag} failed.` }
+  }
+  if (!git(repo.path, ['push', 'origin', tag], { mutating: true, dryRun }).ok) {
+    return { ok: false, message: `git push origin ${tag} failed.` }
+  }
+  return { ok: true }
+}

package/src/ui.js

@@ -0,0 +1,94 @@
+import pc from 'picocolors'
+
+// Column width/row-formatting is shared by `printTable` (the `list` output)
+// and by the checkbox choice labels in `bump`/`switch-master`/`publish` —
+// so a package name column lines up the same way whether it's shown in a
+// static table or as a pickable list, instead of each command reinventing
+// its own ad-hoc padding (which is how columns used to drift out of line
+// once package names of different lengths were mixed in).
+export function columnWidths(rows, columns) {
+  return columns.map((col) =>
+    Math.max(col.label?.length ?? 0, ...rows.map((row) => String(col.value(row)).length)),
+  )
+}
+
+export function formatRow(row, columns, widths, separator = '  ') {
+  return columns
+    .map((col, i) => {
+      const raw = String(col.value(row))
+      const styled = col.style ? col.style(row, raw) : raw
+      const pad = widths[i] - raw.length
+      return styled + ' '.repeat(Math.max(pad, 0))
+    })
+    .join(separator)
+}
+
+// Minimal aligned-column table printer — no extra dependency needed for
+// the handful of columns this CLI ever shows.
+//
+// `groupBy`, when given, inserts a blank line wherever its value changes
+// between consecutive rows — used by `outdated`/`prs`, where several rows
+// belong to the same package, to visually separate one package's rows from
+// the next instead of everything running together. Rows are expected to
+// already be grouped (i.e. sorted by whatever `groupBy` returns) — this
+// only looks at adjacent rows, it doesn't sort.
+export function printTable(rows, columns, { groupBy } = {}) {
+  const widths = columnWidths(rows, columns)
+  const header = columns.map((col, i) => (col.label ?? '').padEnd(widths[i])).join('  ')
+  console.log('')
+  console.log(pc.bold(header))
+  console.log(pc.dim(widths.map((w) => '-'.repeat(w)).join('  ')))
+  let lastGroup
+  rows.forEach((row, i) => {
+    if (groupBy) {
+      const group = groupBy(row)
+      if (i > 0 && group !== lastGroup) console.log('')
+      lastGroup = group
+    }
+    console.log(formatRow(row, columns, widths))
+  })
+}
+
+export function heading(text) {
+  console.log('')
+  console.log(pc.bold(pc.cyan(text)))
+  console.log('')
+}
+
+export function stepHeading(index, total, label) {
+  console.log('')
+  console.log(pc.bold(pc.blue(`[${index}/${total}] ${label}`)))
+}
+
+export function ok(text) {
+  console.log(pc.green(`  ✓ ${text}`))
+}
+
+export function fail(text) {
+  console.log(pc.red(`  ✗ ${text}`))
+}
+
+export function warn(text) {
+  console.log(pc.yellow(`  ! ${text}`))
+}
+
+// Shared theme for every `checkbox`/`select` prompt in this CLI:
+//
+// - `renderSelectedChoices` (checkbox only): the default collapses the
+//   picked items into one comma-joined line once you confirm — unreadable
+//   past a handful of packages. One per line instead.
+// - `keysHelpTip`: both checkbox and select build their "↑↓ navigate •
+//   space select • ⏎ submit"-style footer by calling this with their own
+//   list of [key, action] pairs. Ctrl+C also cancels a prompt (it always
+//   did — see the top-level ExitPromptError handler in index.js, which is
+//   what stops that from crashing with a raw stack trace) but was never
+//   listed here, so it looked unsupported. Appending it — with the exact
+//   same bold-key/dim-action/dim-bullet styling @inquirer uses internally
+//   — makes the footer match what the prompt actually accepts.
+export const promptTheme = {
+  style: {
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => `\n    ${choice.name}`).join(''),
+    keysHelpTip: (keys) =>
+      [...keys, ['ctrl+c', 'cancel']].map(([key, action]) => `${pc.bold(key)} ${pc.dim(action)}`).join(pc.dim(' • ')),
+  },
+}

package/src/version.js

@@ -0,0 +1,29 @@
+// `type` is 'patch' (default), 'minor', or 'major' — a minor bump resets
+// patch to 0, a major bump resets minor and patch to 0, matching semver's
+// own rule for what "the next minor/major" means.
+export function bumpVersion(version, type = 'patch') {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/)
+  if (!match) throw new Error(`Cannot parse version: ${version}`)
+  const [, major, minor, patch, rest] = match
+  if (type === 'major') return `${Number(major) + 1}.0.0${rest}`
+  if (type === 'minor') return `${major}.${Number(minor) + 1}.0${rest}`
+  return `${major}.${minor}.${Number(patch) + 1}${rest}`
+}
+
+export function bumpPatch(version) {
+  return bumpVersion(version, 'patch')
+}
+
+// Text-level replace (not JSON.parse + stringify) so formatting, key
+// order, and quote style in package.json are left untouched — only the
+// first "version" field (the top-level one) changes.
+export function replaceVersionInText(text, newVersion) {
+  let replaced = false
+  const updated = text.replace(/"version"\s*:\s*"([^"]+)"/, (match) => {
+    if (replaced) return match
+    replaced = true
+    return `"version": "${newVersion}"`
+  })
+  if (!replaced) throw new Error('No "version" field found in package.json')
+  return updated
+}

package/test/changelog.test.js

@@ -0,0 +1,101 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { hasChangelog, addChangelogEntry, extractChangelogSection } from '../src/changelog.js'
+
+function makeRepo(changelogContent) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'polyrepo-changelog-test-'))
+  if (changelogContent !== undefined) {
+    fs.writeFileSync(path.join(dir, 'CHANGELOG.md'), changelogContent)
+  }
+  return { path: dir }
+}
+
+test('hasChangelog reflects whether CHANGELOG.md exists', () => {
+  assert.equal(hasChangelog(makeRepo('# Changelog\n')), true)
+  assert.equal(hasChangelog(makeRepo(undefined)), false)
+})
+
+test('addChangelogEntry inserts after "## [Unreleased]" when present', () => {
+  const repo = makeRepo(
+    ['# Changelog', '', '## [Unreleased]', '', '## [1.0.0] - 2026-01-01', '', '### Added', '', '- Initial release.', ''].join(
+      '\n',
+    ),
+  )
+
+  addChangelogEntry(repo, '1.0.1', ['abc123 fix: something real', 'def456 Merge pull request #1 from x/y'])
+
+  const text = fs.readFileSync(path.join(repo.path, 'CHANGELOG.md'), 'utf8')
+  const lines = text.split('\n')
+
+  const unreleasedIdx = lines.findIndex((l) => l.startsWith('## [Unreleased]'))
+  const newIdx = lines.findIndex((l) => l.startsWith('## [1.0.1]'))
+  const oldIdx = lines.findIndex((l) => l.startsWith('## [1.0.0]'))
+
+  assert.ok(unreleasedIdx < newIdx, 'new entry comes after Unreleased')
+  assert.ok(newIdx < oldIdx, 'new entry comes before the previous most-recent release')
+  assert.match(text, /- fix: something real/)
+  // Merge-commit noise must be filtered out of the draft.
+  assert.doesNotMatch(text, /Merge pull request/)
+})
+
+test('addChangelogEntry inserts before the first version heading when there is no Unreleased section', () => {
+  const repo = makeRepo(['# Changelog', '', '## [1.0.0] - 2026-01-01', '', '- Initial release.', ''].join('\n'))
+
+  addChangelogEntry(repo, '1.1.0', [])
+
+  const lines = fs.readFileSync(path.join(repo.path, 'CHANGELOG.md'), 'utf8').split('\n')
+  const newIdx = lines.findIndex((l) => l.startsWith('## [1.1.0]'))
+  const oldIdx = lines.findIndex((l) => l.startsWith('## [1.0.0]'))
+
+  assert.ok(newIdx !== -1 && oldIdx !== -1 && newIdx < oldIdx)
+})
+
+test('addChangelogEntry appends at the end when there are no version headings at all', () => {
+  const repo = makeRepo(['# Changelog', '', 'Nothing released yet.', ''].join('\n'))
+
+  addChangelogEntry(repo, '0.1.0', [])
+
+  const text = fs.readFileSync(path.join(repo.path, 'CHANGELOG.md'), 'utf8')
+  assert.match(text, /## \[0\.1\.0\]/)
+})
+
+test('addChangelogEntry omits the "### Changed" section when there are no real commits to list', () => {
+  const repo = makeRepo(['# Changelog', ''].join('\n'))
+
+  // Only a merge commit — filtered out, so nothing should end up under
+  // "### Changed" at all rather than an empty, pointless heading.
+  addChangelogEntry(repo, '0.1.0', ['abc Merge pull request #2 from x/y'])
+
+  const text = fs.readFileSync(path.join(repo.path, 'CHANGELOG.md'), 'utf8')
+  assert.match(text, /## \[0\.1\.0\]/)
+  assert.doesNotMatch(text, /### Changed/)
+})
+
+test('extractChangelogSection returns the body of one version, and null when missing', () => {
+  const repo = makeRepo(
+    [
+      '# Changelog',
+      '',
+      '## [1.2.0] - 2026-02-01',
+      '',
+      '### Fixed',
+      '',
+      '- A real bug.',
+      '',
+      '## [1.1.0] - 2026-01-01',
+      '',
+      '- Older stuff.',
+      '',
+    ].join('\n'),
+  )
+
+  const section = extractChangelogSection(repo, '1.2.0')
+  assert.match(section, /A real bug/)
+  assert.doesNotMatch(section, /Older stuff/)
+
+  assert.equal(extractChangelogSection(repo, '9.9.9'), null)
+  assert.equal(extractChangelogSection(makeRepo(undefined), '1.0.0'), null)
+})

package/test/crossDeps.test.js

@@ -0,0 +1,51 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { findStaleLocalDeps } from '../src/crossDeps.js'
+
+function makeRepo(name, version, dependencies) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'polyrepo-crossdeps-test-'))
+  const pkgPath = path.join(dir, 'package.json')
+  fs.writeFileSync(pkgPath, JSON.stringify({ name, version, dependencies }, null, 2))
+  return { path: dir, pkgPath, name, version }
+}
+
+test('findStaleLocalDeps flags a dependency range that no longer matches', () => {
+  const dep = makeRepo('color-value-tools', '1.1.12')
+  const dependent = makeRepo('css-magic-gradient', '1.2.14', { 'color-value-tools': '^1.2.0' })
+
+  const issues = findStaleLocalDeps([dep, dependent])
+
+  assert.equal(issues.length, 1)
+  assert.equal(issues[0].repo.dir ?? issues[0].repo.name, dependent.name)
+  assert.equal(issues[0].depName, 'color-value-tools')
+  assert.equal(issues[0].localVersion, '1.1.12')
+})
+
+test('findStaleLocalDeps does not flag a range that still matches', () => {
+  const dep = makeRepo('color-value-tools', '1.1.12')
+  const dependent = makeRepo('css-magic-gradient', '1.2.14', { 'color-value-tools': '^1.1.6' })
+
+  assert.deepEqual(findStaleLocalDeps([dep, dependent]), [])
+})
+
+test('findStaleLocalDeps ignores dependencies on packages outside the given set', () => {
+  const dependent = makeRepo('a', '1.0.0', { vue: '^3.0.0', 'not-a-local-package': '^1.0.0' })
+  assert.deepEqual(findStaleLocalDeps([dependent]), [])
+})
+
+test('findStaleLocalDeps ignores non-semver ranges instead of throwing', () => {
+  const dep = makeRepo('a', '1.0.0')
+  const dependent = makeRepo('b', '1.0.0', { a: 'workspace:*' })
+  assert.deepEqual(findStaleLocalDeps([dep, dependent]), [])
+})
+
+test('findStaleLocalDeps does not flag a package against its own version field', () => {
+  // A package can't meaningfully depend on itself; readPackageDependencies
+  // would only ever see this via a name collision, but the repo === repo
+  // check should short-circuit before it matters either way.
+  const repo = makeRepo('a', '1.0.0', { a: '^2.0.0' })
+  assert.deepEqual(findStaleLocalDeps([repo]), [])
+})

package/test/version.test.js

@@ -0,0 +1,56 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { bumpPatch, bumpVersion, replaceVersionInText } from '../src/version.js'
+
+test('bumpVersion bumps minor and resets patch to 0', () => {
+  assert.equal(bumpVersion('1.2.9', 'minor'), '1.3.0')
+  assert.equal(bumpVersion('1.2.9-beta.1', 'minor'), '1.3.0-beta.1')
+})
+
+test('bumpVersion bumps major and resets minor/patch to 0', () => {
+  assert.equal(bumpVersion('1.2.9', 'major'), '2.0.0')
+  assert.equal(bumpVersion('1.2.9-beta.1', 'major'), '2.0.0-beta.1')
+})
+
+test('bumpVersion defaults to patch', () => {
+  assert.equal(bumpVersion('1.2.9'), '1.2.10')
+})
+
+test('bumpPatch increments the patch number', () => {
+  assert.equal(bumpPatch('1.2.9'), '1.2.10')
+  assert.equal(bumpPatch('0.0.0'), '0.0.1')
+  assert.equal(bumpPatch('10.20.9'), '10.20.10')
+})
+
+test('bumpPatch preserves a pre-release/build suffix', () => {
+  assert.equal(bumpPatch('0.2.7-beta.1'), '0.2.8-beta.1')
+  assert.equal(bumpPatch('1.0.0+build.5'), '1.0.1+build.5')
+})
+
+test('bumpPatch rejects a version it cannot parse', () => {
+  assert.throws(() => bumpPatch('not-a-version'), /Cannot parse version/)
+  assert.throws(() => bumpPatch('1.2'), /Cannot parse version/)
+})
+
+test('replaceVersionInText replaces only the first "version" field', () => {
+  const text = [
+    '{',
+    '  "name": "x",',
+    '  "version": "1.2.9",',
+    '  "nested": { "version": "9.9.9" }',
+    '}',
+    '',
+  ].join('\n')
+
+  const updated = replaceVersionInText(text, '1.2.10')
+
+  assert.match(updated, /"version": "1\.2\.10"/)
+  // The nested, unrelated "version" field must survive untouched.
+  assert.match(updated, /"version": "9\.9\.9"/)
+  // Nothing else about the file's formatting should move.
+  assert.equal(updated.split('\n').length, text.split('\n').length)
+})
+
+test('replaceVersionInText throws when there is no "version" field at all', () => {
+  assert.throws(() => replaceVersionInText('{ "name": "x" }', '1.0.0'), /No "version" field/)
+})