@wmfs/lerna-sync 1.38.0 → 1.39.0

package/lib/plan-sync.js

@@ -0,0 +1,182 @@
+const ACTIONS = Object.freeze({
+  CLONE: 'CLONE',
+  FAST_FORWARD: 'FAST_FORWARD',
+  FETCH_ONLY: 'FETCH_ONLY',
+  NONE: 'NONE'
+})
+
+const REASONS = Object.freeze({
+  NEW: 'NEW',
+  BEHIND: 'BEHIND',
+  UP_TO_DATE: 'UP_TO_DATE',
+  ON_BRANCH: 'ON_BRANCH',
+  DETACHED: 'DETACHED',
+  LOCAL_CHANGES: 'LOCAL_CHANGES',
+  UNSAFE_STATE: 'UNSAFE_STATE',
+  NOT_A_REPO: 'NOT_A_REPO',
+  FOREIGN_ORIGIN: 'FOREIGN_ORIGIN',
+  ORPHANED: 'ORPHANED',
+  NO_LONGER_QUALIFIES: 'NO_LONGER_QUALIFIES',
+  DUPLICATE: 'DUPLICATE'
+})
+
+function planSync ({ remoteRepos, localRepos, router, orgName, packageFolders }) {
+  const key = name => name.toLowerCase() // GitHub repo names are case-insensitive
+  const knownFolders = new Set(packageFolders)
+
+  // 1. Route every remote repo once
+  const remoteByName = new Map()
+  const ignored = []
+
+  for (const remote of remoteRepos) {
+    const route = routeRepo(remote, router, knownFolders)
+    remoteByName.set(key(remote.name), { remote, route })
+    if (!route.folder) {
+      ignored.push({ repoName: remote.name, reason: route.reason })
+    }
+  }
+
+  // 2. Index local repos by the name origin points at, falling back to folder name
+  const localByName = new Map()
+  const decisions = []
+
+  for (const local of localRepos) {
+    const name = key(local.origin?.name || local.repoName)
+    if (localByName.has(name)) {
+      decisions.push(
+        decision(
+          local.repoName,
+          ACTIONS.NONE,
+          REASONS.DUPLICATE,
+          {
+            local,
+            folder: local.folder,
+            warnings: [`Also found at ${localByName.get(name).folder}/${localByName.get(name).repoName}`]
+          }
+        )
+      )
+      continue
+    }
+    localByName.set(name, local)
+  }
+
+  // 3. Repos that exist locally
+  for (const [name, local] of localByName) {
+    const entry = remoteByName.get(name)
+    decisions.push(planLocal(local, entry, orgName))
+  }
+
+  // 4. Qualifying remote repos with no local copy
+  for (const [name, { remote, route }] of remoteByName) {
+    if (!route.folder || localByName.has(name)) continue
+    decisions.push(decision(remote.name, ACTIONS.CLONE, REASONS.NEW, {
+      remote,
+      folder: route.folder,
+      defaultBranch: remote.defaultBranch
+    }))
+  }
+
+  decisions.sort((a, b) =>
+    a.folder.localeCompare(b.folder) || a.repoName.localeCompare(b.repoName)
+  )
+
+  return { decisions, ignored }
+}
+
+function planLocal (local, entry, orgName) {
+  const base = { local, folder: local.folder }
+
+  if (!local.isGitRepo) {
+    // A plain folder where a qualifying repo would be cloned: don't overwrite it
+    return decision(local.repoName, ACTIONS.NONE, REASONS.NOT_A_REPO, {
+      ...base,
+      remote: entry?.remote || null,
+      warnings: entry?.route.folder ? ['Folder exists but is not a git repo, so it cannot be cloned into'] : []
+    })
+  }
+
+  if (local.origin?.owner && local.origin.owner.toLowerCase() !== orgName.toLowerCase()) {
+    return decision(local.repoName, ACTIONS.NONE, REASONS.FOREIGN_ORIGIN, {
+      ...base,
+      warnings: [`origin points at ${local.origin.url}`]
+    })
+  }
+
+  if (!entry) {
+    return decision(local.repoName, ACTIONS.NONE, REASONS.ORPHANED, base)
+  }
+
+  const { remote, route } = entry
+  const withRemote = { ...base, remote, defaultBranch: remote.defaultBranch, warnings: [] }
+
+  if (!route.folder) {
+    return decision(local.repoName, ACTIONS.NONE, REASONS.NO_LONGER_QUALIFIES, {
+      ...withRemote,
+      warnings: [route.reason]
+    })
+  }
+
+  if (route.folder !== local.folder) {
+    withRemote.warnings.push(`Lives in /${local.folder} but is now routed to /${route.folder}`)
+  }
+
+  if (!local.statusKnown || local.operationInProgress || !local.headSha) {
+    return decision(local.repoName, ACTIONS.NONE, REASONS.UNSAFE_STATE, withRemote)
+  }
+
+  if (local.isDetached) {
+    return decision(local.repoName, ACTIONS.FETCH_ONLY, REASONS.DETACHED, withRemote)
+  }
+
+  if (local.branch !== remote.defaultBranch) {
+    return decision(local.repoName, ACTIONS.FETCH_ONLY, REASONS.ON_BRANCH, withRemote)
+  }
+
+  if (local.headSha === remote.sha) {
+    return decision(local.repoName, ACTIONS.NONE, REASONS.UP_TO_DATE, withRemote)
+  }
+
+  if (local.trackedChanges > 0) {
+    return decision(local.repoName, ACTIONS.FETCH_ONLY, REASONS.LOCAL_CHANGES, withRemote)
+  }
+
+  // On the default branch, clean, and HEAD differs from GitHub.
+  // Usually that means behind. If it has local commits instead, --ff-only
+  // will refuse and the executor reports it as diverged.
+  return decision(local.repoName, ACTIONS.FAST_FORWARD, REASONS.BEHIND, withRemote)
+}
+
+function routeRepo (remote, router, knownFolders) {
+  if (!remote.packageJson) return { folder: null, reason: 'No package.json' }
+
+  let result
+  try {
+    result = router(remote.packageJson)
+  } catch (e) {
+    return { folder: null, reason: `Router threw: ${e.message}` }
+  }
+
+  // Backwards compatible: a string means "route here", null/undefined means "not ours".
+  // A router can also return { skip: 'reason' } so the report can say why.
+  if (result == null) return { folder: null, reason: 'Not selected by router' }
+  if (typeof result === 'object' && result.skip) return { folder: null, reason: result.skip }
+  if (typeof result !== 'string') return { folder: null, reason: `Router returned ${JSON.stringify(result)}` }
+  if (!knownFolders.has(result)) return { folder: null, reason: `Router chose "${result}", which is not in lerna.json` }
+
+  return { folder: result, reason: null }
+}
+
+function decision (repoName, action, reason, extra = {}) {
+  return {
+    repoName,
+    action,
+    reason,
+    folder: extra.folder,
+    defaultBranch: extra.defaultBranch || extra.remote?.defaultBranch || null,
+    remote: extra.remote || null,
+    local: extra.local || null,
+    warnings: extra.warnings || []
+  }
+}
+
+module.exports = { planSync, ACTIONS, REASONS }

package/lib/report.js

@@ -0,0 +1,195 @@
+const chalk = require('chalk')
+const { ACTIONS, REASONS } = require('./plan-sync')
+const { OUTCOMES } = require('./execute-plan')
+
+const attention = (name, detail, commits) => ({ group: 'attention', name, detail, commits })
+const housekeeping = (name, detail) => ({ group: 'housekeeping', name, detail })
+const firstLine = s => (s || '').split('\n')[0]
+
+function report (plan, results, { verbose = false } = {}) {
+  const resultFor = new Map(results.map(r => [r.decision, r]))
+  const groups = { branches: [], cloned: [], updated: [], attention: [], housekeeping: [], errors: [] }
+  let okCount = 0
+  let depsMayHaveChanged = false
+
+  for (const d of plan.decisions) {
+    const r = resultFor.get(d)
+    const entry = classify(d, r)
+    if (!entry) {
+      okCount++
+    } else {
+      groups[entry.group].push({ ...entry, warnings: d.warnings })
+    }
+    if (r && (r.outcome === OUTCOMES.CLONED || r.packageJsonChanged)) depsMayHaveChanged = true
+  }
+
+  section('Cloned', groups.cloned, chalk.green)
+  section('Updated', groups.updated, chalk.cyan)
+  section('On branches (left alone)', groups.branches, chalk.blue)
+  section('Needs your attention', groups.attention, chalk.yellow)
+  section('Housekeeping', groups.housekeeping, chalk.gray)
+  section('Errors', groups.errors, chalk.red)
+
+  if (verbose && plan.ignored.length) {
+    console.log(chalk.gray(`\nIgnored ${plan.ignored.length} repos:`))
+    plan.ignored.forEach(i => console.log(chalk.gray(`  ${i.repoName}: ${i.reason}`)))
+  }
+
+  console.log('')
+  console.log(
+    `${chalk.green(okCount)} up to date, ${groups.cloned.length} cloned, ${groups.updated.length} updated, ` +
+    `${chalk.yellow(groups.attention.length)} need attention, ${chalk.red(groups.errors.length)} errors`
+  )
+
+  if (depsMayHaveChanged) {
+    console.log(chalk.yellow('\nDependencies may have changed. Reinstall/relink before running anything.'))
+  }
+
+  return { errorCount: groups.errors.length, attentionCount: groups.attention.length }
+}
+
+function classify (d, r) {
+  const name = `${d.folder}/${d.repoName}`
+
+  if (!r) {
+    switch (d.reason) {
+      case REASONS.UP_TO_DATE: return null
+      case REASONS.UNSAFE_STATE: return attention(name, 'Mid-merge/rebase or unreadable status, skipped')
+      case REASONS.FOREIGN_ORIGIN: return attention(name, 'origin is not this org, skipped')
+      case REASONS.NOT_A_REPO:
+        return d.warnings.length
+          ? attention(name, 'Folder exists but is not a git repo, cannot clone')
+          : housekeeping(name, 'Not a git repo')
+      case REASONS.ORPHANED: return housekeeping(name, 'No longer in the org (deleted, archived or renamed)')
+      case REASONS.NO_LONGER_QUALIFIES: return housekeeping(name, 'No longer selected for sync')
+      case REASONS.DUPLICATE: return housekeeping(name, 'Duplicate clone')
+      default: return housekeeping(name, d.reason)
+    }
+  }
+
+  const branch = d.local?.branch
+  switch (r.outcome) {
+    case OUTCOMES.CLONED:
+      return { group: 'cloned', name, detail: d.remote.packageJson?.description }
+    case OUTCOMES.UPDATED:
+      return { group: 'updated', name, detail: `${r.behind} new commit${r.behind === 1 ? '' : 's'}`, commits: r.commits }
+    case OUTCOMES.CURRENT:
+      if (d.reason === REASONS.ON_BRANCH) return { group: 'branches', name, detail: `on ${branch}, nothing new on ${d.defaultBranch}` }
+      if (d.reason === REASONS.DETACHED) return { group: 'branches', name, detail: 'detached HEAD, nothing new' }
+      return null
+    case OUTCOMES.BEHIND:
+      if (d.reason === REASONS.ON_BRANCH) return attention(name, `On ${branch}: ${d.defaultBranch} has ${r.behind} commit(s) you don't`, r.commits)
+      if (d.reason === REASONS.DETACHED) return attention(name, `Detached HEAD: ${d.defaultBranch} is ${r.behind} commit(s) ahead`, r.commits)
+      return attention(name, `Uncommitted changes on ${d.defaultBranch}: ${r.behind} commit(s) not pulled`, r.commits)
+    case OUTCOMES.LOCAL_AHEAD:
+      return attention(name, `${r.ahead} unpushed commit(s) on ${d.defaultBranch}`)
+    case OUTCOMES.DIVERGED:
+      return attention(name, `${d.defaultBranch} has diverged (${r.ahead} ahead, ${r.behind} behind), not pulled`, r.commits)
+    case OUTCOMES.BLOCKED_BY_UNTRACKED:
+      return attention(name, 'Untracked files would be overwritten, not pulled', r.commits)
+    case OUTCOMES.FAILED:
+      return { group: 'errors', name, detail: r.error }
+  }
+}
+
+function section (title, entries, colour) {
+  if (!entries.length) return
+  console.log('')
+  console.log(chalk.underline(`${title} (${entries.length})`))
+  for (const e of entries) {
+    console.log(`  ${colour(e.name)}${e.detail ? chalk.gray(` ${e.detail}`) : ''}`)
+    for (const w of e.warnings || []) console.log(chalk.yellow(`    ! ${w}`))
+    for (const c of e.commits || []) console.log(chalk.gray(`    ${c.sha} ${c.subject} (${c.author}, ${c.when})`))
+  }
+}
+
+function printPlan (plan, { verbose = false } = {}) {
+  const groups = { clone: [], fastForward: [], fetchOnly: [], attention: [], housekeeping: [] }
+
+  let okCount = 0
+
+  for (const d of plan.decisions) {
+    const name = `${d.folder}/${d.repoName}`
+    const warnings = d.warnings
+
+    switch (d.action) {
+      case ACTIONS.CLONE:
+        groups.clone.push({ name, detail: d.remote.packageJson?.description, warnings })
+        break
+      case ACTIONS.FAST_FORWARD:
+        groups.fastForward.push({ name, warnings })
+        break
+      case ACTIONS.FETCH_ONLY:
+        groups.fetchOnly.push({ name, detail: fetchOnlyDetail(d), warnings })
+        break
+      default: {
+        // NONE decisions: the same wording as the real report
+        const entry = classify(d, undefined)
+        if (!entry) okCount++
+        else groups[entry.group].push({ ...entry, warnings })
+      }
+    }
+  }
+
+  console.log(chalk.bold('\nDry run: nothing has been changed'))
+  section('Would clone', groups.clone, chalk.green)
+  section('Would fast-forward', groups.fastForward, chalk.cyan)
+  section('Would fetch only (your branch is left alone)', groups.fetchOnly, chalk.yellow)
+  section('Needs your attention', groups.attention, chalk.yellow)
+  section('Housekeeping', groups.housekeeping, chalk.gray)
+
+  if (verbose && plan.ignored.length) {
+    console.log(chalk.gray(`\nIgnored ${plan.ignored.length} repos:`))
+    plan.ignored.forEach(i => console.log(chalk.gray(`  ${i.repoName}: ${i.reason}`)))
+  }
+
+  console.log('')
+  console.log(
+    `${chalk.green(okCount)} up to date, ${groups.clone.length} to clone, ` +
+    `${groups.fastForward.length} to fast-forward, ${groups.fetchOnly.length} to fetch`
+  )
+}
+
+function fetchOnlyDetail (d) {
+  switch (d.reason) {
+    case REASONS.ON_BRANCH: return `on ${d.local.branch}`
+    case REASONS.DETACHED: return 'detached HEAD'
+    case REASONS.LOCAL_CHANGES: return `uncommitted changes on ${d.defaultBranch}`
+    default: return d.reason
+  }
+}
+
+function describeResult (r) {
+  const d = r.decision
+  const base = d.defaultBranch || 'master'
+  const branch = d.local?.branch
+  const n = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`
+
+  switch (r.outcome) {
+    case OUTCOMES.CLONED:
+      return { label: 'Cloned', colour: chalk.green }
+    case OUTCOMES.UPDATED:
+      return { label: 'Updated', colour: chalk.cyan, detail: `pulled ${n(r.behind, 'commit')}` }
+    case OUTCOMES.CURRENT:
+      if (d.reason === REASONS.ON_BRANCH) return { label: 'On branch', colour: chalk.blue, detail: `${branch}, nothing new on ${base}` }
+      if (d.reason === REASONS.DETACHED) return { label: 'Detached', colour: chalk.blue, detail: `nothing new on ${base}` }
+      if (d.reason === REASONS.LOCAL_CHANGES) return { label: 'Up to date', colour: chalk.green, detail: 'has uncommitted changes' }
+      return { label: 'Up to date', colour: chalk.green }
+    case OUTCOMES.BEHIND:
+      if (d.reason === REASONS.ON_BRANCH) return { label: 'On branch', colour: chalk.yellow, detail: `${branch}, ${base} has ${n(r.behind, 'new commit')}` }
+      if (d.reason === REASONS.DETACHED) return { label: 'Detached', colour: chalk.yellow, detail: `${base} has ${n(r.behind, 'new commit')}` }
+      return { label: 'Not pulled', colour: chalk.yellow, detail: `uncommitted changes, ${base} has ${n(r.behind, 'new commit')}` }
+    case OUTCOMES.LOCAL_AHEAD:
+      return { label: 'Unpushed', colour: chalk.yellow, detail: `${n(r.ahead, 'local commit')} on ${base}` }
+    case OUTCOMES.DIVERGED:
+      return { label: 'Diverged', colour: chalk.yellow, detail: `${r.ahead} ahead, ${r.behind} behind, not pulled` }
+    case OUTCOMES.BLOCKED_BY_UNTRACKED:
+      return { label: 'Not pulled', colour: chalk.yellow, detail: 'untracked files would be overwritten' }
+    case OUTCOMES.FAILED:
+      return { label: 'Failed', colour: chalk.red, detail: firstLine(r.error) }
+    default:
+      return { label: r.outcome, colour: chalk.gray }
+  }
+}
+
+module.exports = { report, printPlan, describeResult }

package/lib/utils/git.js

@@ -0,0 +1,59 @@
+const { execFile } = require('child_process')
+
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000
+
+// Sync runs many git commands in parallel with no one watching their output,
+// so git must fail fast rather than wait for input that will never come.
+function nonInteractiveEnv () {
+  const env = {
+    ...process.env,
+    // Never prompt in the terminal for a username/password
+    GIT_TERMINAL_PROMPT: '0'
+  }
+
+  // Never prompt for an SSH passphrase or to accept an unknown host key.
+  // Keys loaded in ssh-agent still work. Respect a command the user already set.
+  if (!env.GIT_SSH_COMMAND && !env.GIT_SSH) {
+    env.GIT_SSH_COMMAND = 'ssh -o BatchMode=yes'
+  }
+
+  return env
+}
+
+function git (args, cwd, { timeout = DEFAULT_TIMEOUT_MS } = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      'git',
+      ['-c', 'core.quotepath=false', ...args],
+      {
+        cwd,
+        timeout,
+        windowsHide: true,
+        maxBuffer: 10 * 1024 * 1024,
+        env: nonInteractiveEnv()
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          err.stderr = stderr
+          if (err.killed) {
+            const limit = timeout >= 1000 ? `${Math.round(timeout / 1000)}s` : `${timeout}ms`
+            err.message = `git ${args[0]} timed out after ${limit}`
+          }
+          return reject(err)
+        }
+        // trimEnd, not trim: `git status --porcelain` lines can start with a space
+        resolve(stdout.trimEnd())
+      }
+    )
+  })
+}
+
+async function tryGit (args, cwd, options) {
+  try {
+    return await git(args, cwd, options)
+  } catch (e) {
+    return null
+  }
+}
+
+module.exports = { git, tryGit, DEFAULT_TIMEOUT_MS }

package/lib/utils/map-limit.js

@@ -0,0 +1,17 @@
+module.exports = async function mapLimit (items, limit, fn) {
+  // A NaN or 0 limit would start no workers and silently return an array of holes
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError(`mapLimit: limit must be a positive integer, got ${limit}`)
+  }
+  const results = new Array(items.length)
+  let next = 0
+  async function worker () {
+    while (next < items.length) {
+      const i = next++
+      results[i] = await fn(items[i], i)
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, items.length) }, worker)
+  await Promise.all(workers)
+  return results
+}

package/lib/utils/package-folders-from-patterns.js

@@ -0,0 +1,25 @@
+const GLOB_CHARS = /[*?[\]{}!]/
+
+function packageFoldersFromPatterns (patterns) {
+  const folders = new Set()
+
+  for (const raw of patterns) {
+    const pattern = raw.trim().replace(/\\/g, '/').replace(/\/+$/, '')
+
+    // Negations like "!packages/legacy" exclude folders, they don't add one
+    if (pattern.startsWith('!')) continue
+
+    // Only "<folder>/*" can be a clone target: lerna-sync clones to <folder>/<repoName>
+    const match = pattern.match(/^(.+)\/\*$/)
+    if (!match || GLOB_CHARS.test(match[1])) {
+      console.warn(`lerna-sync: ignoring package pattern "${raw}", expected "<folder>/*"`)
+      continue
+    }
+
+    folders.add(match[1].replace(/^\.\//, ''))
+  }
+
+  return [...folders]
+}
+
+module.exports = packageFoldersFromPatterns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wmfs/lerna-sync",
-  "version": "1.38.0",
+  "version": "1.39.0",
   "description": "A package to synchronize distributed GitHub repos inside a Lerna monorepo.",
   "author": "West Midlands Fire Service",
   "homepage": "https://github.com/wmfs/lerna-sync#readme",
@@ -22,22 +22,22 @@
   "directories": {
     "lib": "lib"
   },
+  "engines": {
+    "node": ">=20"
+  },
   "dependencies": {
-    "@octokit/graphql": "5.0.4",
+    "@octokit/graphql": "7.1.1",
     "chalk": "4.1.2",
-    "dottie": "2.0.6",
-    "git-repo-info": "2.1.1",
     "glob": "11.1.0",
     "humanize-duration": "3.33.0",
-    "jsonfile": "6.1.0",
-    "lodash": "4.17.21"
+    "jsonfile": "6.1.0"
   },
   "devDependencies": {
     "chai": "4.5.0",
     "codecov": "3.8.3",
     "conventional-changelog-conventionalcommits": "9.3.1",
     "cz-conventional-changelog": "3.3.0",
-    "mocha": "12.0.2",
+    "mocha": "12.0.3",
     "nyc": "18.0.0",
     "semantic-release": "25.0.9",
     "standard": "17.1.2",

package/test/discover-spec.js

@@ -0,0 +1,128 @@
+/* eslint-env mocha */
+
+const { expect } = require('chai')
+const { captureConsole } = require('./helpers/fixtures')
+const discover = require('../lib/discover')
+
+// A GraphQL node as GitHub returns it
+function node (name, overrides = {}) {
+  return {
+    name,
+    isArchived: false,
+    isPrivate: false,
+    packageJson: { text: JSON.stringify({ name, keywords: ['tymly'] }), isTruncated: false },
+    defaultBranchRef: {
+      name: 'master',
+      target: {
+        oid: `${name}-sha`,
+        messageHeadline: `Commit on ${name}`,
+        author: { name: 'Someone', date: '2026-01-01T00:00:00Z' }
+      }
+    },
+    ...overrides
+  }
+}
+
+// Stand-in for the octokit client: serves pages in order and records calls
+function fakeGraphql (pages) {
+  const calls = []
+  const fn = async (query, variables) => {
+    calls.push(variables)
+    const index = calls.length - 1
+    const nodes = pages[index]
+    const hasNextPage = index < pages.length - 1
+    return {
+      organization: {
+        repositories: {
+          nodes,
+          pageInfo: { hasNextPage, endCursor: hasNextPage ? `cursor-${index + 1}` : null }
+        }
+      }
+    }
+  }
+  fn.calls = calls
+  return fn
+}
+
+describe('discover', () => {
+  let output
+  beforeEach(() => { output = captureConsole() })
+  afterEach(() => output.restore())
+
+  it('maps GitHub nodes to plain remote records', async () => {
+    const [repo] = await discover(fakeGraphql([[node('a')]]), 'wmfs')
+    expect(repo).to.deep.equal({
+      name: 'a',
+      isPrivate: false,
+      defaultBranch: 'master',
+      sha: 'a-sha',
+      messageHeadline: 'Commit on a',
+      author: { name: 'Someone', date: '2026-01-01T00:00:00Z' },
+      packageJson: { name: 'a', keywords: ['tymly'] }
+    })
+  })
+
+  it('follows pagination cursors until the last page', async () => {
+    const graphql = fakeGraphql([[node('a'), node('b')], [node('c')], [node('d')]])
+    const repos = await discover(graphql, 'wmfs')
+
+    expect(repos.map(r => r.name)).to.deep.equal(['a', 'b', 'c', 'd'])
+    expect(graphql.calls).to.deep.equal([
+      { org: 'wmfs', after: null },
+      { org: 'wmfs', after: 'cursor-1' },
+      { org: 'wmfs', after: 'cursor-2' }
+    ])
+  })
+
+  it('uses each repo\'s real default branch', async () => {
+    const main = node('a')
+    main.defaultBranchRef.name = 'main'
+    const [repo] = await discover(fakeGraphql([[main]]), 'wmfs')
+    expect(repo.defaultBranch).to.equal('main')
+  })
+
+  it('skips archived and empty repos', async () => {
+    const repos = await discover(fakeGraphql([[
+      node('archived', { isArchived: true }),
+      node('empty', { defaultBranchRef: null }),
+      node('kept')
+    ]]), 'wmfs')
+    expect(repos.map(r => r.name)).to.deep.equal(['kept'])
+  })
+
+  it('keeps repos with no package.json, with packageJson null', async () => {
+    const [repo] = await discover(fakeGraphql([[node('a', { packageJson: null })]]), 'wmfs')
+    expect(repo.packageJson).to.equal(null)
+  })
+
+  it('treats invalid JSON as no package.json, with a warning', async () => {
+    const [repo] = await discover(fakeGraphql([[
+      node('broken', { packageJson: { text: '{ not json', isTruncated: false } })
+    ]]), 'wmfs')
+    expect(repo.packageJson).to.equal(null)
+    expect(output.text()).to.include('Unable to parse package.json for broken')
+  })
+
+  it('treats a truncated blob as no package.json, with a warning', async () => {
+    const [repo] = await discover(fakeGraphql([[
+      node('huge', { packageJson: { text: '{"name":', isTruncated: true } })
+    ]]), 'wmfs')
+    expect(repo.packageJson).to.equal(null)
+    expect(output.text()).to.include('truncated')
+  })
+
+  it('returns an empty list for an org with no repos', async () => {
+    expect(await discover(fakeGraphql([[]]), 'wmfs')).to.deep.equal([])
+  })
+
+  it('lets GraphQL errors propagate', async () => {
+    const failing = async () => { throw new Error('Bad credentials') }
+    let error
+    try {
+      await discover(failing, 'wmfs')
+    } catch (e) {
+      error = e
+    }
+    expect(error && error.message).to.equal('Bad credentials')
+  })
+})