code-foundry 1.2.0 → 1.3.0

package/src/lib/config.mjs

@@ -16,7 +16,10 @@ export function readConfig(file) {
   for (const line of readFileSync(file, 'utf8').split(/\r?\n/)) {
     const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/)
     if (!match) continue
-    const value = match[2].replace(/\s+#.*$/, '').trim().replace(/^['"]|['"]$/g, '')
+    const value = match[2]
+      .replace(/\s+#.*$/, '')
+      .trim()
+      .replace(/^['"]|['"]$/g, '')
     config[match[1]] = value
   }
   return config
@@ -29,7 +32,10 @@ export function configured(value, fallback) {
 
 /** @param {string} value @returns {string[]} */
 export function listValue(value) {
-  return value.split(',').map((item) => item.trim()).filter(Boolean)
+  return value
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
 }
 
 /** @param {string} value @param {string} item */

package/src/lib/github-doctor.mjs

@@ -18,21 +18,39 @@ export function doctorGithub(root) {
   const rulesets = hydrateRulesets(repository, ghJson(['api', `repos/${repository}/rulesets`]))
   const mainRulesets = rulesetsForBranch(rulesets, 'main')
   const protection = ghJson(['api', `repos/${repository}/branches/main/protection`])
-  const required = mainRulesets.length ? requiredContextsFromRulesets(mainRulesets) : requiredContextsFromProtection(protection)
+  const required = mainRulesets.length
+    ? requiredContextsFromRulesets(mainRulesets)
+    : requiredContextsFromProtection(protection)
   details.requiredChecks = required
-  if (!protection && !mainRulesets.length) warnings.push('main branch protection or repository rulesets are not readable or are not configured.')
-  else if (!required.length) warnings.push(mainRulesets.length ? 'main ruleset has no required status checks.' : 'main protection has no required status checks.')
+  if (!protection && !mainRulesets.length)
+    warnings.push(
+      'main branch protection or repository rulesets are not readable or are not configured.'
+    )
+  else if (!required.length)
+    warnings.push(
+      mainRulesets.length
+        ? 'main ruleset has no required status checks.'
+        : 'main protection has no required status checks.'
+    )
   const duplicateNames = required.filter((name) => /\b([^/]+) \/ \1\b/i.test(name))
-  if (duplicateNames.length) errors.push(`required checks contain duplicate workflow prefixes: ${duplicateNames.join(', ')}`)
+  if (duplicateNames.length)
+    errors.push(`required checks contain duplicate workflow prefixes: ${duplicateNames.join(', ')}`)
 
   const sha = String(ghJson(['api', `repos/${repository}/git/ref/heads/main`])?.object?.sha ?? '')
-  const checks = sha ? ghJson(['api', `repos/${repository}/commits/${sha}/check-runs?per_page=100`])?.check_runs ?? [] : []
+  const checks = sha
+    ? (ghJson(['api', `repos/${repository}/commits/${sha}/check-runs?per_page=100`])?.check_runs ??
+      [])
+    : []
   const observed = checks.map(/** @param {any} check */ (check) => check.name).filter(Boolean)
   details.observedChecks = observed
-  if (!observed.length) warnings.push('no check runs were observed on the current main commit; exact check validation is deferred until CI runs.')
+  if (!observed.length)
+    warnings.push(
+      'no check runs were observed on the current main commit; exact check validation is deferred until CI runs.'
+    )
   if (required.length) {
     const missing = required.filter((name) => observed.length && !observed.includes(name))
-    if (missing.length) warnings.push(`required checks not observed on current main: ${missing.join(', ')}`)
+    if (missing.length)
+      warnings.push(`required checks not observed on current main: ${missing.join(', ')}`)
   }
 
   const workflowIssues = inspectWorkflows(root)
@@ -40,34 +58,79 @@ export function doctorGithub(root) {
   warnings.push(...workflowIssues.warnings)
 
   const secrets = ghJson(['secret', 'list', '--repo', repository, '--json', 'name'])
-  const secretNames = Array.isArray(secrets) ? secrets.map(/** @param {any} secret */ (secret) => secret.name) : []
+  const secretNames = Array.isArray(secrets)
+    ? secrets.map(/** @param {any} secret */ (secret) => secret.name)
+    : []
   details.secrets = {
     codeFoundryTokenPresent: secretNames.includes('CODE_FOUNDRY_TOKEN'),
     stagingDeployKeyPresent: secretNames.includes('STAGING_DEPLOY_KEY'),
   }
   if (!details.secrets.codeFoundryTokenPresent) {
-    warnings.push('CODE_FOUNDRY_TOKEN is absent. PR workflow triggers and automation may require manual readiness.')
+    warnings.push(
+      'CODE_FOUNDRY_TOKEN is absent. PR workflow triggers and automation may require manual readiness.'
+    )
   }
 
   const config = readConfig(root)
-  if (['workflow-dispatch', 'dispatch'].includes(config.post_release_mode) && config.post_release !== 'false' && !details.secrets.codeFoundryTokenPresent && !details.secrets.releasePleaseTokenPresent) {
+  if (
+    ['workflow-dispatch', 'dispatch'].includes(config.post_release_mode) &&
+    config.post_release !== 'false' &&
+    !details.secrets.codeFoundryTokenPresent &&
+    !details.secrets.releasePleaseTokenPresent
+  ) {
     errors.push('post-release workflow-dispatch mode requires CODE_FOUNDRY_TOKEN to be present.')
   }
   const credentialChecks = {
     npmTokenPresent: secretNames.includes('NPM_TOKEN'),
     turboTokenPresent: secretNames.includes('TURBO_TOKEN'),
-    turboTeamPresent: Boolean(ghJson(['variable', 'list', '--repo', repository, '--json', 'name'])?.some(/** @param {{ name?: string }} variable */ (variable) => variable.name === 'TURBO_TEAM')),
+    turboTeamPresent: Boolean(
+      ghJson(['variable', 'list', '--repo', repository, '--json', 'name'])?.some(
+        /** @param {{ name?: string }} variable */ (variable) => variable.name === 'TURBO_TEAM'
+      )
+    ),
     opencodeApiKeyPresent: secretNames.includes('OPENCODE_API_KEY'),
   }
   details.credentials = credentialChecks
-  if (config.npm_publish === 'true' && !credentialChecks.npmTokenPresent) warnings.push('npm_publish is enabled but NPM_TOKEN is not configured; npm trusted publishing must be configured for tokenless publication.')
-  if (['true', 'auto'].includes(config.turbo_remote ?? 'false') && (!credentialChecks.turboTokenPresent || !credentialChecks.turboTeamPresent)) warnings.push('turbo_remote is enabled but TURBO_TOKEN and/or TURBO_TEAM is not configured; remote caching will be skipped.')
-  if (['true', 'auto'].includes(config.opencode_security ?? 'false') && !credentialChecks.opencodeApiKeyPresent) warnings.push('opencode_security is enabled but OPENCODE_API_KEY is not configured; the optional scan will be skipped.')
+  if (config.npm_publish === 'true' && !credentialChecks.npmTokenPresent)
+    warnings.push(
+      'npm_publish is enabled but NPM_TOKEN is not configured; npm trusted publishing must be configured for tokenless publication.'
+    )
+  if (
+    ['true', 'auto'].includes(config.turbo_remote ?? 'false') &&
+    (!credentialChecks.turboTokenPresent || !credentialChecks.turboTeamPresent)
+  )
+    warnings.push(
+      'turbo_remote is enabled but TURBO_TOKEN and/or TURBO_TEAM is not configured; remote caching will be skipped.'
+    )
+  if (
+    ['true', 'auto'].includes(config.opencode_security ?? 'false') &&
+    !credentialChecks.opencodeApiKeyPresent
+  )
+    warnings.push(
+      'opencode_security is enabled but OPENCODE_API_KEY is not configured; the optional scan will be skipped.'
+    )
 
-  const prs = ghJson(['pr', 'list', '--repo', repository, '--state', 'open', '--base', 'main', '--json', 'number,title,headRefName'])
+  const prs = ghJson([
+    'pr',
+    'list',
+    '--repo',
+    repository,
+    '--state',
+    'open',
+    '--base',
+    'main',
+    '--json',
+    'number,title,headRefName',
+  ])
   const openPrs = Array.isArray(prs) ? prs : []
-  details.openPromotionPrs = openPrs.filter(/** @param {any} pr */ (pr) => pr.headRefName === 'staging' || /promote staging/i.test(pr.title))
-  details.openReleasePrs = openPrs.filter(/** @param {any} pr */ (pr) => String(pr.headRefName).startsWith('release-please--') || /^chore\(main\): release /.test(pr.title))
+  details.openPromotionPrs = openPrs.filter(
+    /** @param {any} pr */ (pr) => pr.headRefName === 'staging' || /promote staging/i.test(pr.title)
+  )
+  details.openReleasePrs = openPrs.filter(
+    /** @param {any} pr */ (pr) =>
+      String(pr.headRefName).startsWith('release-please--') ||
+      pr.title.startsWith('chore(main): release ')
+  )
   if (details.openPromotionPrs.length > 1) errors.push('multiple staging promotion PRs are open.')
   if (details.openReleasePrs.length > 1) errors.push('multiple Release Please PRs are open.')
   return { errors, warnings, details }
@@ -75,23 +138,33 @@ export function doctorGithub(root) {
 
 /** @param {any} protection @returns {string[]} */
 function requiredContextsFromProtection(protection) {
-  return [...new Set([
-    ...(protection?.required_status_checks?.contexts ?? []),
-    ...(protection?.required_status_checks?.checks ?? []).map(/** @param {any} check */ (check) => check.context),
-  ].filter(Boolean))]
+  return [
+    ...new Set(
+      [
+        ...(protection?.required_status_checks?.contexts ?? []),
+        ...(protection?.required_status_checks?.checks ?? []).map(
+          /** @param {any} check */ (check) => check.context
+        ),
+      ].filter(Boolean)
+    ),
+  ]
 }
 
 /** @param {any[]} rulesets @returns {string[]} */
 function requiredContextsFromRulesets(rulesets) {
-  return [...new Set(
-    (Array.isArray(rulesets) ? rulesets : []).flatMap((/** @type {any} */ ruleset) =>
-      (ruleset.rules ?? []).flatMap((/** @type {any} */ rule) =>
-        rule?.type === 'required_status_checks' ?
-          (rule.parameters?.required_status_checks ?? []).map((/** @type {any} */ check) => check?.context).filter(Boolean) :
-          []
-      ),
+  return [
+    ...new Set(
+      (Array.isArray(rulesets) ? rulesets : []).flatMap((/** @type {any} */ ruleset) =>
+        (ruleset.rules ?? []).flatMap((/** @type {any} */ rule) =>
+          rule?.type === 'required_status_checks'
+            ? (rule.parameters?.required_status_checks ?? [])
+                .map((/** @type {any} */ check) => check?.context)
+                .filter(Boolean)
+            : []
+        )
+      )
     ),
-  )]
+  ]
 }
 
 /** @param {string} repository @param {any[] | null} rulesets @returns {any[]} */
@@ -107,13 +180,14 @@ function hydrateRulesets(repository, rulesets) {
 /** @param {any[] | null} rulesets @param {string} branch @returns {any[]} */
 function rulesetsForBranch(rulesets, branch) {
   if (!Array.isArray(rulesets)) return []
-  return rulesets.filter((ruleset) => (
-    ruleset?.target === 'branch' &&
-    Array.isArray(ruleset?.conditions?.ref_name?.include) &&
-    Array.isArray(ruleset?.conditions?.ref_name?.exclude) &&
-    includesBranch(ruleset.conditions.ref_name.include, branch) &&
-    !includesBranch(ruleset.conditions.ref_name.exclude, branch)
-  ))
+  return rulesets.filter(
+    (ruleset) =>
+      ruleset?.target === 'branch' &&
+      Array.isArray(ruleset?.conditions?.ref_name?.include) &&
+      Array.isArray(ruleset?.conditions?.ref_name?.exclude) &&
+      includesBranch(ruleset.conditions.ref_name.include, branch) &&
+      !includesBranch(ruleset.conditions.ref_name.exclude, branch)
+  )
 }
 
 /** @param {(string | null | undefined)[]} patterns @param {string} branch @returns {boolean} */
@@ -123,8 +197,11 @@ function includesBranch(patterns, branch) {
     if (!pattern) return false
     if (pattern === '~ALL') return true
     if (pattern === target || pattern === branch) return true
-    if (!/[\*?]/.test(pattern)) return false
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*').replace(/\\\?/g, '.')
+    if (!/[*?]/.test(pattern)) return false
+    const escaped = pattern
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\\\*/g, '.*')
+      .replace(/\\\?/g, '.')
     const regex = new RegExp(`^${escaped}$`)
     return regex.test(target) || regex.test(branch)
   })
@@ -139,12 +216,21 @@ function inspectWorkflows(root) {
   const directory = join(root, '.github/workflows')
   /** @type {string[]} */
   let files = []
-  try { files = readdirSync(directory).filter((file) => file.endsWith('.yml') || file.endsWith('.yaml')) }
-  catch { return { errors: ['.github/workflows is missing.'], warnings } }
+  try {
+    files = readdirSync(directory).filter((file) => file.endsWith('.yml') || file.endsWith('.yaml'))
+  } catch {
+    return { errors: ['.github/workflows is missing.'], warnings }
+  }
   for (const file of files) {
     const content = readFileSync(join(directory, file), 'utf8')
-    if (!/^permissions:\s*$/m.test(content) && /uses:.*\.github\/workflows\//.test(content)) warnings.push(`${file} does not declare top-level permissions.`)
-    if (file === 'release.yml' && /contents:\s+write/.test(content) && !/pull-requests:\s+write/.test(content)) errors.push('release.yml needs pull-requests: write for guarded Release Please PR handling.')
+    if (!/^permissions:\s*$/m.test(content) && /uses:.*\.github\/workflows\//.test(content))
+      warnings.push(`${file} does not declare top-level permissions.`)
+    if (
+      file === 'release.yml' &&
+      /contents:\s+write/.test(content) &&
+      !/pull-requests:\s+write/.test(content)
+    )
+      errors.push('release.yml needs pull-requests: write for guarded Release Please PR handling.')
   }
   return { errors, warnings }
 }
@@ -153,27 +239,43 @@ function inspectWorkflows(root) {
 function remoteRepository(root) {
   const result = spawnSync('git', ['remote', 'get-url', 'origin'], { cwd: root, encoding: 'utf8' })
   const value = result.status === 0 ? result.stdout.trim() : ''
-  return value.replace(/^git@github\.com:/, '').replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '')
+  return value
+    .replace(/^git@github\.com:/, '')
+    .replace(/^https?:\/\/github\.com\//, '')
+    .replace(/\.git$/, '')
 }
 
 /** @param {string[]} args @returns {any} */
 function ghJson(args) {
   const result = spawnSync('gh', args, { encoding: 'utf8' })
   if (result.status !== 0) return null
-  try { return JSON.parse(result.stdout) }
-  catch { return null }
+  try {
+    return JSON.parse(result.stdout)
+  } catch {
+    return null
+  }
 }
 
 /** @param {string} command */
-function commandExists(command) { return spawnSync(command, ['--version'], { stdio: 'ignore' }).status === 0 }
+function commandExists(command) {
+  return spawnSync(command, ['--version'], { stdio: 'ignore' }).status === 0
+}
 
 /** @param {string} root @returns {Record<string, string>} */
 function readConfig(root) {
   const file = join(root, '.github/code-foundry.yml')
   try {
-    return Object.fromEntries(readFileSync(file, 'utf8').split(/\r?\n/).flatMap((line) => {
-      const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/)
-      return match ? [[match[1], match[2].replace(/\s+#.*$/, '').replace(/^['"]|['"]$/g, '')]] : []
-    }))
-  } catch { return {} }
+    return Object.fromEntries(
+      readFileSync(file, 'utf8')
+        .split(/\r?\n/)
+        .flatMap((line) => {
+          const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/)
+          return match
+            ? [[match[1], match[2].replace(/\s+#.*$/, '').replace(/^['"]|['"]$/g, '')]]
+            : []
+        })
+    )
+  } catch {
+    return {}
+  }
 }

package/src/lib/overlay.mjs

@@ -23,7 +23,11 @@ export function customWorkflowFiles(root, standardFiles) {
 export function overlayPolicy(root, config) {
   const mode = config.sync_mode ?? 'overlay'
   const custom = config.custom_workflows ?? 'preserve'
-  if (!['overlay', 'strict'].includes(mode)) throw new Error(`Unsupported sync_mode: ${mode}; use overlay or strict.`)
-  if (custom !== 'preserve') throw new Error(`Unsupported custom_workflows: ${custom}; custom workflows are always preserved.`)
+  if (!['overlay', 'strict'].includes(mode))
+    throw new Error(`Unsupported sync_mode: ${mode}; use overlay or strict.`)
+  if (custom !== 'preserve')
+    throw new Error(
+      `Unsupported custom_workflows: ${custom}; custom workflows are always preserved.`
+    )
   return { mode, custom_workflows: custom }
 }

package/src/lib/profile.mjs

@@ -47,15 +47,19 @@ export function detectLanguages(root) {
   if (
     existsSync(join(root, 'package.json')) ||
     files.some((file) => /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/.test(file)) ||
-    files.some((file) => /(?:bun\.lockb?|pnpm-lock\.yaml|yarn\.lock|package-lock\.json)$/.test(file))
-  ) languages.push('typescript')
+    files.some((file) =>
+      /(?:bun\.lockb?|pnpm-lock\.yaml|yarn\.lock|package-lock\.json)$/.test(file)
+    )
+  )
+    languages.push('typescript')
   if (existsSync(join(root, 'Cargo.toml')) || hasSource(root, /\.rs$/)) languages.push('rust')
   if (
     existsSync(join(root, 'pyproject.toml')) ||
     existsSync(join(root, 'requirements.txt')) ||
     existsSync(join(root, 'requirements-dev.txt')) ||
     hasSource(root, /\.py$/)
-  ) languages.push('python')
+  )
+    languages.push('python')
   if (files.some((file) => file.endsWith('.sol'))) languages.push('solidity')
   return languages.length ? languages : ['none']
 }
@@ -72,16 +76,23 @@ export function detectPackageManager(root) {
 
 /** @param {string} root */
 export function detectProfile(root) {
-  if (existsSync(join(root, 'turbo.json')) || existsSync(join(root, 'pnpm-workspace.yaml'))) return 'monorepo'
+  if (existsSync(join(root, 'turbo.json')) || existsSync(join(root, 'pnpm-workspace.yaml')))
+    return 'monorepo'
   if (existsSync(join(root, 'package.json'))) {
     try {
       const packageJson = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
-      if (Array.isArray(packageJson.workspaces) || typeof packageJson.workspaces === 'object') return 'monorepo'
+      if (Array.isArray(packageJson.workspaces) || typeof packageJson.workspaces === 'object')
+        return 'monorepo'
     } catch {
       // Doctor reports malformed package.json separately.
     }
   }
-  if (existsSync(join(root, 'package.json')) || existsSync(join(root, 'pyproject.toml')) || existsSync(join(root, 'Cargo.toml'))) return 'application'
+  if (
+    existsSync(join(root, 'package.json')) ||
+    existsSync(join(root, 'pyproject.toml')) ||
+    existsSync(join(root, 'Cargo.toml'))
+  )
+    return 'application'
   return 'minimal'
 }
 
@@ -110,7 +121,9 @@ export function resolveProfile(root) {
  */
 export function recommendRunners(root) {
   const languages = detectLanguages(root)
-  const heavy = languages.some((language) => ['rust', 'python', 'solidity'].includes(language)) || hasBrowserProject(root)
+  const heavy =
+    languages.some((language) => ['rust', 'python', 'solidity'].includes(language)) ||
+    hasBrowserProject(root)
   return {
     runner: heavy ? 'ubuntu-latest' : 'ubuntu-slim',
     ci_runner: heavy ? 'ubuntu-latest' : 'ubuntu-slim',
@@ -125,7 +138,12 @@ export function recommendRunners(root) {
 
 /** @param {string} root */
 function hasBrowserProject(root) {
-  return ['playwright.config.ts', 'playwright.config.js', 'cypress.config.ts', 'cypress.config.js'].some((file) => existsSync(join(root, file)))
+  return [
+    'playwright.config.ts',
+    'playwright.config.js',
+    'cypress.config.ts',
+    'cypress.config.js',
+  ].some((file) => existsSync(join(root, file)))
 }
 
 /** @param {string} root */

package/src/lib/release-hook.mjs

@@ -11,16 +11,26 @@ import { createHash } from 'node:crypto'
  */
 export function selectHookDelivery(input) {
   const mode = input.mode ?? 'auto'
-  if (mode === 'false' || mode === 'disabled') return { delivery: 'disabled', reason: 'Post-release hooks are disabled by configuration.' }
+  if (mode === 'false' || mode === 'disabled')
+    return { delivery: 'disabled', reason: 'Post-release hooks are disabled by configuration.' }
   if (mode === 'workflow-dispatch' || (mode === 'auto' && input.tokenPresent)) {
     return input.tokenPresent
-      ? { delivery: 'workflow-dispatch', reason: 'A PAT is available; use one explicit workflow dispatch.' }
+      ? {
+          delivery: 'workflow-dispatch',
+          reason: 'A PAT is available; use one explicit workflow dispatch.',
+        }
       : { delivery: 'unavailable', reason: 'workflow-dispatch requires a PAT.' }
   }
   if (mode === 'release-event' || (mode === 'auto' && input.releaseEventEnabled !== false)) {
-    return { delivery: 'release-event', reason: 'Use the published-release event; do not issue a fallback dispatch.' }
+    return {
+      delivery: 'release-event',
+      reason: 'Use the published-release event; do not issue a fallback dispatch.',
+    }
+  }
+  return {
+    delivery: 'unavailable',
+    reason: 'No supported post-release delivery mechanism is configured.',
   }
-  return { delivery: 'unavailable', reason: 'No supported post-release delivery mechanism is configured.' }
 }
 
 /** @param {string} repository @param {string} tag @returns {string} */
@@ -36,5 +46,7 @@ export function releaseDeliveryKey(repository, tag) {
  * @param {string} tag
  */
 export function hasDeliveredHook(runs, tag) {
-  return runs.some((run) => run.headBranch === tag || run.displayTitle?.includes(`release-tag=${tag}`))
+  return runs.some(
+    (run) => run.headBranch === tag || run.displayTitle?.includes(`release-tag=${tag}`)
+  )
 }

package/src/lib/release-manifest.mjs

@@ -3,7 +3,27 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 
-const ignored = new Set(['.git', '.code-foundry', '.venv', 'node_modules', 'target', 'vendor', 'dist', 'build', '.next', '.kilo', '.turbo', '.cache', '.vercel', '.output', '.nuxt', '.svelte-kit', '.parcel-cache', 'out', 'coverage'])
+const ignored = new Set([
+  '.git',
+  '.code-foundry',
+  '.venv',
+  'node_modules',
+  'target',
+  'vendor',
+  'dist',
+  'build',
+  '.next',
+  '.kilo',
+  '.turbo',
+  '.cache',
+  '.vercel',
+  '.output',
+  '.nuxt',
+  '.svelte-kit',
+  '.parcel-cache',
+  'out',
+  'coverage',
+])
 
 /** @typedef {{ directory: string, manifest: string, releaseType: 'node'|'python'|'rust', packageName?: string, extraFiles: string[] }} ReleasePackage */
 
@@ -16,11 +36,29 @@ export function detectReleasePackages(root) {
     const directory = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : '.'
     if (name === 'package.json') {
       const parsed = readJson(join(root, file))
-      packages.push({ directory, manifest: file, releaseType: 'node', packageName: typeof parsed?.name === 'string' ? parsed.name : undefined, extraFiles: detectExtraFiles(root, directory) })
+      packages.push({
+        directory,
+        manifest: file,
+        releaseType: 'node',
+        packageName: typeof parsed?.name === 'string' ? parsed.name : undefined,
+        extraFiles: detectExtraFiles(root, directory),
+      })
     } else if (name === 'Cargo.toml') {
-      packages.push({ directory, manifest: file, releaseType: 'rust', packageName: tomlPackageName(join(root, file)), extraFiles: detectExtraFiles(root, directory) })
+      packages.push({
+        directory,
+        manifest: file,
+        releaseType: 'rust',
+        packageName: tomlPackageName(join(root, file)),
+        extraFiles: detectExtraFiles(root, directory),
+      })
     } else if (name === 'pyproject.toml') {
-      packages.push({ directory, manifest: file, releaseType: 'python', packageName: pyprojectName(join(root, file)), extraFiles: detectExtraFiles(root, directory) })
+      packages.push({
+        directory,
+        manifest: file,
+        releaseType: 'python',
+        packageName: pyprojectName(join(root, file)),
+        extraFiles: detectExtraFiles(root, directory),
+      })
     }
   })
   return packages.sort((a, b) => a.directory.localeCompare(b.directory))
@@ -45,19 +83,22 @@ export function buildReleaseConfig(root, existing = {}) {
     const extra = Array.isArray(result['extra-files']) ? result['extra-files'] : []
     result['extra-files'] = extra
     for (const file of packages[0].extraFiles) {
-      if (!extra.some((entry) => (typeof entry === 'string' ? entry : entry?.path) === file)) extra.push(file)
+      if (!extra.some((entry) => (typeof entry === 'string' ? entry : entry?.path) === file))
+        extra.push(file)
     }
     return result
   }
   /** @type {Record<string, any>} */
-  const configuredPackages = { ...(result.packages ?? {}) }
+  const configuredPackages = { ...result.packages }
   for (const entry of packages) {
-    const current = { ...(configuredPackages[entry.directory] ?? {}) }
+    const current = { ...configuredPackages[entry.directory] }
     current['release-type'] ??= entry.releaseType
     if (entry.packageName) current['package-name'] ??= entry.packageName
     /** @type {any[]} */
     const extra = Array.isArray(current['extra-files']) ? [...current['extra-files']] : []
-    for (const file of entry.extraFiles) if (!extra.some((item) => (typeof item === 'string' ? item : item?.path) === file)) extra.push(file)
+    for (const file of entry.extraFiles)
+      if (!extra.some((item) => (typeof item === 'string' ? item : item?.path) === file))
+        extra.push(file)
     if (extra.length) current['extra-files'] = extra
     configuredPackages[entry.directory] = current
   }
@@ -75,9 +116,12 @@ export function buildReleaseConfig(root, existing = {}) {
  * @returns {Record<string, string>|null}
  */
 export function buildReleaseManifest(root, config = {}) {
-  const packages = config.packages && typeof config.packages === 'object' && !Array.isArray(config.packages)
-    ? config.packages
-    : config['release-type'] ? { '.': {} } : null
+  const packages =
+    config.packages && typeof config.packages === 'object' && !Array.isArray(config.packages)
+      ? config.packages
+      : config['release-type']
+        ? { '.': {} }
+        : null
   if (!packages || !Object.keys(packages).length) return null
   /** @type {Record<string, string>} */
   const manifest = {}
@@ -94,7 +138,9 @@ function readDirectoryVersion(directory) {
     try {
       const parsed = JSON.parse(readFileSync(packagePath, 'utf8'))
       if (typeof parsed?.version === 'string' && parsed.version) return parsed.version
-    } catch { /* fall through to other manifests */ }
+    } catch {
+      /* fall through to other manifests */
+    }
   }
   for (const file of ['pyproject.toml', 'Cargo.toml']) {
     const path = join(directory, file)
@@ -110,13 +156,17 @@ export function validateReleaseConfig(root, config) {
   const detected = detectReleasePackages(root)
   if (!detected.length) return []
   const configured = config.packages && typeof config.packages === 'object' ? config.packages : null
-  if (detected.length > 1 && !configured) return ['mixed-language or multi-package repositories require release-please packages configuration']
+  if (detected.length > 1 && !configured)
+    return [
+      'mixed-language or multi-package repositories require release-please packages configuration',
+    ]
   if (!configured) return []
   const errors = []
   for (const entry of detected) {
     const item = configured[entry.directory]
     if (!item) errors.push(`release-please packages is missing ${entry.directory}`)
-    else if (item['release-type'] !== entry.releaseType) errors.push(`${entry.directory} release-type should be ${entry.releaseType}`)
+    else if (item['release-type'] !== entry.releaseType)
+      errors.push(`${entry.directory} release-type should be ${entry.releaseType}`)
   }
   return errors
 }
@@ -137,17 +187,29 @@ function walk(root, visit) {
 
 /** @param {string} root @param {string} directory @returns {string[]} */
 function detectExtraFiles(root, directory) {
-  const candidates = ['version.txt', 'VERSION', '.version', 'version.json', 'src/version.ts', 'src/version.js', 'src/version.py', 'src/version.rs']
+  const candidates = [
+    'version.txt',
+    'VERSION',
+    '.version',
+    'version.json',
+    'src/version.ts',
+    'src/version.js',
+    'src/version.py',
+    'src/version.rs',
+  ]
   return candidates
-    .map((file) => directory === '.' ? file : `${directory}/${file}`)
+    .map((file) => (directory === '.' ? file : `${directory}/${file}`))
     .filter((file) => existsSync(join(root, file)))
-    .map((file) => directory === '.' ? file : file.slice(directory.length + 1))
+    .map((file) => (directory === '.' ? file : file.slice(directory.length + 1)))
 }
 
 /** @param {string} file @returns {any} */
 function readJson(file) {
-  try { return JSON.parse(readFileSync(file, 'utf8')) }
-  catch { return {} }
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'))
+  } catch {
+    return {}
+  }
 }
 
 /** @param {string} file @returns {string|undefined} */