@emeryld/manager 0.2.0 → 0.2.2

package/src/release.ts

@@ -1,410 +0,0 @@
-// src/release.js
-import { readFile, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import { stageCommitPush } from './git.js'
-import { askLine, promptSingleKey, promptYesNoAll } from './prompts.js'
-import { bumpVersion, isSemver, type BumpType } from './semver.js'
-import type { LoadedPackage } from './utils/log.js'
-import { colors, formatPkgName, logGlobal, logPkg } from './utils/log.js'
-import { run } from './utils/run.js'
-
-// in release.js
-
-type VersionStrategy =
-  | { mode: 'bump'; bumpType: BumpType; preid?: string }
-  | { mode: 'sync'; version: string }
-  | { mode: 'noop' }
-
-export interface PublishOptions {
-  nonInteractive?: boolean
-  bumpType?: BumpType // used when nonInteractive, now includes pre* types
-  preid?: string // e.g. "alpha" | "beta" | "rc"
-  syncVersion?: string // used when nonInteractive
-  tag?: string // e.g. "next" or "beta"
-  dryRun?: boolean
-  provenance?: boolean
-  // Optional: used only for git tag message, if you want:
-  releaseNotes?: string
-}
-
-export interface PublishOptions {
-  nonInteractive?: boolean
-  bumpType?: BumpType // used when nonInteractive
-  syncVersion?: string // used when nonInteractive
-  tag?: string // e.g. "next" or "beta"
-  dryRun?: boolean
-  provenance?: boolean
-}
-
-const bumpMap: Record<string, BumpType> = {
-  '1': 'patch',
-  '2': 'minor',
-  '3': 'major',
-  // mapped from pre-release submenu later, but keep named keys for nonInteractive
-  patch: 'patch',
-  minor: 'minor',
-  major: 'major',
-  prepatch: 'prepatch',
-  preminor: 'preminor',
-  premajor: 'premajor',
-  prerelease: 'prerelease',
-}
-
-function preBumpFromChoice(choice: string): BumpType | undefined {
-  switch (choice) {
-    case '1':
-      return 'prepatch'
-    case '2':
-      return 'preminor'
-    case '3':
-      return 'premajor'
-    case '4':
-      return 'prerelease'
-    default:
-      return undefined
-  }
-}
-
-async function writePackageJson(pkgPath: string, json: unknown) {
-  await writeFile(pkgPath, `${JSON.stringify(json, null, 2)}\n`)
-}
-
-async function refreshPackagesFromDisk(pkgs: LoadedPackage[]) {
-  await Promise.all(
-    pkgs.map(async (pkg) => {
-      const raw = await readFile(pkg.packageJsonPath, 'utf8')
-      const json = JSON.parse(raw)
-      pkg.json = json
-      pkg.version = json.version ?? pkg.version
-      if (json.name) pkg.name = json.name
-    }),
-  )
-}
-
-async function ensureNpmAuth() {
-  try {
-    await run('pnpm', ['whoami'])
-  } catch {
-    throw new Error(
-      'Not authenticated to registry. Run "pnpm login" and retry.',
-    )
-  }
-}
-
-function ensureNotPrivate(targets: LoadedPackage[]) {
-  const privates = targets.filter((p) => p.json?.private)
-  if (privates.length) {
-    const names = privates.map((p) => p.name).join(', ')
-    throw new Error(`Refusing to publish private packages: ${names}`)
-  }
-}
-
-async function publishPackage(pkg: LoadedPackage, opts: PublishOptions = {}) {
-  const args = ['publish', '--access', 'public']
-
-  let tag = opts.tag
-  if (!tag) {
-    tag = inferTagFromVersion(pkg.version || '')
-  }
-  if (tag) args.push('--tag', tag)
-
-  if (opts.dryRun) args.push('--dry-run')
-  if (opts.provenance) args.push('--provenance')
-
-  logPkg(pkg, `Publishing ${pkg.name}…`, colors.green)
-  try {
-    await run('pnpm', args, { cwd: pkg.path })
-    logPkg(pkg, `${pkg.name} published.`, colors.green)
-
-    const tagName = `${pkg.name}@${pkg.version}`
-    const tagMessage = opts.releaseNotes
-      ? `release ${pkg.version}\n\n${opts.releaseNotes}`
-      : `release ${pkg.version}`
-
-    await run('git', ['tag', '-a', tagName, '-m', tagMessage])
-    await run('git', ['push', 'origin', tagName])
-  } catch (err) {
-    console.error(colors.red(`Publish failed for ${pkg.name}.`))
-    console.error(
-      colors.dim('To revert the version commit: git revert HEAD && git push'),
-    )
-    throw err
-  }
-}
-
-async function applyVersionStrategy(
-  strategy: VersionStrategy,
-  targetPkg: LoadedPackage,
-  packages: LoadedPackage[],
-  opts: PublishOptions = {},
-): Promise<{ changedPaths: string[]; commitMessage: string }> {
-  if (strategy.mode === 'noop') {
-    console.log('\nSkipping version bump (no version change selected).')
-    return { changedPaths: [], commitMessage: '' }
-  }
-
-  if (strategy.mode === 'sync') {
-    console.log()
-    logGlobal('Syncing all package versions…', colors.cyan)
-    await run('pnpm', ['sync', strategy.version])
-    packages.forEach((pkg) => {
-      pkg.version = strategy.version
-      pkg.json.version = strategy.version
-    })
-    return {
-      changedPaths: [
-        'package.json',
-        ...packages.map((pkg) =>
-          path.relative(process.cwd(), pkg.packageJsonPath),
-        ),
-      ],
-      commitMessage: `chore(release): sync ${strategy.version}`,
-    }
-  }
-
-  // mode === 'bump'
-  const nextVersion = bumpVersion(
-    targetPkg.version,
-    strategy.bumpType,
-    strategy.preid,
-  )
-  console.log(
-    `\nUpdating ${formatPkgName(targetPkg)} version to ${colors.green(nextVersion)}`,
-  )
-  targetPkg.json.version = nextVersion
-  targetPkg.version = nextVersion
-  await writePackageJson(targetPkg.packageJsonPath, targetPkg.json)
-  return {
-    changedPaths: [path.relative(process.cwd(), targetPkg.packageJsonPath)],
-    commitMessage: opts?.releaseNotes
-      ? `chore(release): ${targetPkg.name}@${nextVersion} - ${opts.releaseNotes}`
-      : `chore(release): ${targetPkg.name}@${nextVersion}`,
-  }
-}
-
-function strategyFromOptions(
-  targetPkg: LoadedPackage,
-  selection: LoadedPackage[],
-  opts?: PublishOptions,
-): VersionStrategy | undefined {
-  if (!opts?.nonInteractive) return undefined
-  if (opts.syncVersion) {
-    if (!isSemver(opts.syncVersion))
-      throw new Error(`Invalid version "${opts.syncVersion}"`)
-    return { mode: 'sync', version: opts.syncVersion }
-  }
-  if (opts.bumpType)
-    return { mode: 'bump', bumpType: opts.bumpType, preid: opts.preid }
-  return { mode: 'noop' }
-}
-
-function inferTagFromVersion(version: string): string | undefined {
-  const match = version.match(/-([0-9A-Za-z-]+)(?:\.\d+)?$/)
-  if (!match) return undefined
-  const preid = match[1].toLowerCase()
-  if (['alpha', 'beta', 'rc'].includes(preid)) return preid
-  return 'next'
-}
-
-function inferPreidFromVersion(version: string): string | undefined {
-  const match = version.match(/-([0-9A-Za-z-]+)/)
-  return match?.[1]?.toLowerCase()
-}
-
-export async function promptVersionStrategy(
-  targetPkg: LoadedPackage,
-  selection: LoadedPackage[],
-  opts?: PublishOptions,
-): Promise<VersionStrategy> {
-  const viaOpts = strategyFromOptions(targetPkg, selection, opts)
-  if (viaOpts) return viaOpts
-
-  console.log('\nCurrent package versions:')
-  for (const pkg of selection) {
-    const marker =
-      selection.length === 1 && pkg.dirName === targetPkg.dirName ? '*' : '•'
-    console.log(
-      ` ${marker} ${formatPkgName(pkg)} ${pkg.dirName} ${colors.yellow(pkg.version)}`,
-    )
-  }
-
-  console.log('\nSelect version strategy:')
-  console.log(' 1) Patch')
-  console.log(' 2) Minor')
-  console.log(' 3) Major')
-  console.log(' 4) Pre-release (alpha / beta / rc)')
-  console.log(' 5) Sync packages')
-  console.log(' 6) No version change')
-
-  const choice = await promptSingleKey('Choice: ', (key) => {
-    if (['1', '2', '3', '4', '5', '6'].includes(key)) return key
-    return undefined
-  })
-  console.log(choice)
-
-  // Sync
-  if (choice === '5') {
-    const desired = await askLine('Enter unified version: ')
-    if (!isSemver(desired)) throw new Error(`Invalid version "${desired}"`)
-    return { mode: 'sync', version: desired }
-  }
-
-  // No version change
-  if (choice === '6') {
-    const ans = await promptYesNoAll('Publish without changing any versions?')
-    if (ans === 'no') {
-      console.log('Aborting.')
-      process.exit(0)
-    }
-    return { mode: 'noop' }
-  }
-
-  // Pre-release submenu
-  let preid: string | undefined
-  let bumpType: BumpType | undefined
-
-  if (choice === '4') {
-    const currentVersion = targetPkg.version || '?'
-    const defaultPreid = inferPreidFromVersion(currentVersion) || 'alpha'
-    const preview = (type: BumpType) => {
-      try {
-        return bumpVersion(currentVersion, type, defaultPreid)
-      } catch {
-        return '?'
-      }
-    }
-
-    console.log('\nSelect pre-release bump type:')
-    console.log(` 1) prepatch   (${currentVersion} -> ${preview('prepatch')})`)
-    console.log(` 2) preminor   (${currentVersion} -> ${preview('preminor')})`)
-    console.log(` 3) premajor   (${currentVersion} -> ${preview('premajor')})`)
-    console.log(
-      ` 4) prerelease (${currentVersion} -> ${preview('prerelease')})`,
-    )
-
-    const preChoice = await promptSingleKey('Choice: ', (key) => {
-      if (['1', '2', '3', '4'].includes(key)) return key
-      return undefined
-    })
-    console.log(preChoice)
-
-    bumpType = preBumpFromChoice(preChoice)
-    if (!bumpType) throw new Error('Invalid pre-release selection.')
-
-    const rawPreid = await askLine(
-      'Pre-release identifier (e.g. alpha, beta, rc) [alpha]: ',
-    )
-    preid = (rawPreid.trim() || 'alpha').toLowerCase()
-  } else {
-    // Regular patch / minor / major
-    bumpType = bumpMap[choice] as BumpType | undefined
-  }
-
-  if (!bumpType) throw new Error('Invalid selection.')
-
-  // Preview what will happen
-  if (selection.length === 1) {
-    const proposed = bumpVersion(targetPkg.version, bumpType, preid)
-    console.log(
-      `\nTarget package: ${formatPkgName(targetPkg)} -> ${colors.green(proposed)}`,
-    )
-    const others = selection.filter((pkg) => pkg.dirName !== targetPkg.dirName)
-    if (others.length) {
-      console.log('Other packages:')
-      others.forEach((pkg) => {
-        console.log(` - ${formatPkgName(pkg)} ${colors.yellow(pkg.version)}`)
-      })
-    }
-  } else {
-    console.log(
-      `\nApplying a ${bumpType}${
-        preid ? ` (${preid})` : ''
-      } bump to all selected packages:`,
-    )
-    selection.forEach((pkg) => {
-      const nextVersion = bumpVersion(pkg.version, bumpType!, preid)
-      const arrow = nextVersion === pkg.version ? '─' : '→'
-      console.log(
-        ` - ${formatPkgName(pkg)} ${colors.yellow(pkg.version)} ${arrow} ${colors.green(
-          nextVersion,
-        )}`,
-      )
-    })
-  }
-
-  const confirm = await promptYesNoAll(
-    selection.length === 1
-      ? `Apply ${bumpType}${preid ? ` (${preid})` : ''} bump to ${targetPkg.name}?`
-      : `Apply ${bumpType}${preid ? ` (${preid})` : ''} bump to all selected packages?`,
-  )
-  if (confirm === 'no') {
-    console.log('Aborting.')
-    process.exit(0)
-  }
-
-  return { mode: 'bump', bumpType, preid }
-}
-
-export async function releaseSingle(
-  targetPkg: LoadedPackage,
-  packages: LoadedPackage[],
-  opts: PublishOptions = {},
-) {
-  await ensureNpmAuth()
-  await refreshPackagesFromDisk([targetPkg])
-  ensureNotPrivate([targetPkg])
-
-  console.log(`\n${formatPkgName(targetPkg)} ${colors.dim('(single release)')}`)
-  const strategy = await promptVersionStrategy(targetPkg, [targetPkg], opts)
-  const { changedPaths, commitMessage } = await applyVersionStrategy(
-    strategy,
-    targetPkg,
-    packages,
-    opts,
-  )
-  await stageCommitPush(changedPaths, commitMessage)
-  await publishPackage(targetPkg, opts)
-}
-
-export async function releaseMultiple(
-  targets: LoadedPackage[],
-  packages: LoadedPackage[],
-  opts: PublishOptions = {},
-) {
-  await ensureNpmAuth()
-  await refreshPackagesFromDisk(targets)
-  ensureNotPrivate(targets)
-
-  console.log(`\n🚀 ${'*'} Publishing all selected packages`)
-  const strategy = await promptVersionStrategy(targets[0], targets, opts)
-  let changedPaths: string[] = []
-  let commitMessage = ''
-
-  if (strategy.mode === 'sync') {
-    const result = await applyVersionStrategy(
-      strategy,
-      targets[0],
-      packages,
-      opts,
-    )
-    changedPaths = result.changedPaths
-    commitMessage = result.commitMessage
-  } else if (strategy.mode === 'bump') {
-    for (const pkg of targets) {
-      const result = await applyVersionStrategy(strategy, pkg, packages, opts)
-      changedPaths.push(...result.changedPaths)
-    }
-    commitMessage = `chore(release): ${targets.map((p) => `${p.name}@${p.version}`).join(', ')}`
-  }
-
-  if (changedPaths.length || commitMessage) {
-    await stageCommitPush(
-      changedPaths,
-      commitMessage || `chore(release): publish ${targets.length} package(s)`,
-    )
-  }
-
-  for (const pkg of targets) {
-    await publishPackage(pkg, opts)
-  }
-}

package/src/semver.ts

@@ -1,27 +0,0 @@
-// src/semver.js
-import { inc, valid,  } from 'semver'
-
-export type BumpType =
-  | 'patch'
-  | 'minor'
-  | 'major'
-  | 'prepatch'
-  | 'preminor'
-  | 'premajor'
-  | 'prerelease'
-
-export function bumpVersion(version: string, type: BumpType, preid?: string) {
-  let next
-  if (preid) {
-    next = inc(version, type as any, preid)
-  } else {
-    next = inc(version, type as any)
-  }
-  if (!next)
-    throw new Error(`Cannot bump invalid version "${version}" by "${type}"`)
-  return next
-}
-
-export function isSemver(version: string) {
-  return Boolean(valid(version))
-}

package/src/sync-version.mjs

@@ -1,213 +0,0 @@
-#!/usr/bin/env node
-import { readFile, writeFile, readdir } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-const rootDir = process.cwd()
-const ansi = (code) => (text) => `\x1b[${code}m${text}\x1b[0m`
-const colors = {
-  cyan: ansi(36),
-  green: ansi(32),
-  yellow: ansi(33),
-  magenta: ansi(35),
-  red: ansi(31),
-  dim: ansi(2),
-}
-
-const palette = ['cyan', 'green', 'yellow', 'magenta', 'red']
-
-function manifestFilePath() {
-  return path.join(rootDir, 'scripts', 'packages.mjs')
-}
-
-function normalizeManifestPath(value) {
-  const absolute = path.resolve(rootDir, value || '')
-  let relative = path.relative(rootDir, absolute)
-  if (!relative) return ''
-  relative = relative.replace(/\\/g, '/')
-  return relative.replace(/^(?:\.\/)+/, '')
-}
-
-function colorFromSeed(seed) {
-  const normalized = `${seed}`.trim() || 'package'
-  let hash = 0
-  for (let i = 0; i < normalized.length; i++) {
-    hash = (hash * 31 + normalized.charCodeAt(i)) >>> 0
-  }
-  return palette[hash % palette.length]
-}
-
-function isManifestMissing(error) {
-  if (typeof error !== 'object' || error === null) return false
-  const code = error.code
-  return code === 'ERR_MODULE_NOT_FOUND' || code === 'ENOENT'
-}
-
-async function loadWorkspaceManifest() {
-  const manifestPath = manifestFilePath()
-  try {
-    const manifestModule = await import(pathToFileURL(manifestPath).href)
-    if (Array.isArray(manifestModule?.PACKAGE_MANIFEST)) {
-      return manifestModule.PACKAGE_MANIFEST
-    }
-  } catch (error) {
-    if (isManifestMissing(error)) return undefined
-    throw error
-  }
-  return undefined
-}
-
-async function inferManifestFromWorkspace() {
-  try {
-    const packagesDir = path.join(rootDir, 'packages')
-    const entries = await readdir(packagesDir, { withFileTypes: true })
-    const manifest = []
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue
-      const pkgJsonPath = path.join(packagesDir, entry.name, 'package.json')
-      try {
-        const raw = await readFile(pkgJsonPath, 'utf8')
-        const json = JSON.parse(raw)
-        const pkgName = (json.name || entry.name).trim() || entry.name
-        manifest.push({
-          name: pkgName,
-          path: normalizeManifestPath(path.relative(rootDir, path.join(packagesDir, entry.name))),
-          color: colorFromSeed(pkgName),
-        })
-      } catch {
-        continue
-      }
-    }
-    return manifest
-  } catch {
-    return []
-  }
-}
-
-function mergeManifestEntries(inferred, overrides) {
-  const normalizedOverrides = new Map()
-  overrides?.forEach((entry) => {
-    const normalized = normalizeManifestPath(entry.path)
-    if (!normalized) return
-    normalizedOverrides.set(normalized, { ...entry, path: normalized })
-  })
-
-  const merged = []
-  for (const baseEntry of inferred) {
-    const normalized = normalizeManifestPath(baseEntry.path)
-    const override = normalizedOverrides.get(normalized)
-    if (override) {
-      normalizedOverrides.delete(normalized)
-      const name = override.name || baseEntry.name
-      const color = override.color ?? baseEntry.color ?? colorFromSeed(name)
-      merged.push({ name, path: normalized, color })
-    } else {
-      merged.push({ ...baseEntry, path: normalized })
-    }
-  }
-
-  normalizedOverrides.forEach((entry) => {
-    const name = entry.name || path.basename(entry.path) || 'package'
-    const color = entry.color ?? colorFromSeed(name)
-    merged.push({ name, path: entry.path, color })
-  })
-
-  return merged
-}
-
-const registerPackageEntry = (map, pkgPath, entry) => {
-  if (!map.has(pkgPath)) {
-    map.set(pkgPath, entry)
-  }
-}
-
-async function collectPackageEntries() {
-  const packagesDir = path.join(rootDir, 'packages')
-  const records = new Map()
-
-  registerPackageEntry(records, path.join(rootDir, 'package.json'), {
-    name: 'workspace root',
-    pkgPath: path.join(rootDir, 'package.json'),
-    color: 'magenta',
-  })
-
-  const [workspaceManifest, inferred] = await Promise.all([
-    loadWorkspaceManifest(),
-    inferManifestFromWorkspace(),
-  ])
-  const manifestEntries = mergeManifestEntries(inferred, workspaceManifest)
-
-  for (const manifestEntry of manifestEntries) {
-    if (!manifestEntry.path) continue
-    const pkgPath = path.join(rootDir, manifestEntry.path, 'package.json')
-    registerPackageEntry(records, pkgPath, {
-      name: manifestEntry.name,
-      pkgPath,
-      color: manifestEntry.color ?? colorFromSeed(manifestEntry.name),
-    })
-  }
-
-  try {
-    const entries = await readdir(packagesDir, { withFileTypes: true })
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue
-      const pkgPath = path.join(packagesDir, entry.name, 'package.json')
-      registerPackageEntry(records, pkgPath, {
-        name: entry.name,
-        pkgPath,
-        color: colorFromSeed(entry.name),
-      })
-    }
-  } catch (error) {
-    console.error(`Failed to read packages directory: ${error}`)
-  }
-
-  return Array.from(records.values())
-}
-
-async function main() {
-  const version = process.argv[2]
-
-  if (!version) {
-    console.error('Usage: pnpm sync <version>')
-    process.exitCode = 1
-    return
-  }
-
-  const semverPattern = /^\d+\.\d+\.\d+(?:[-+].*)?$/
-  if (!semverPattern.test(version)) {
-    console.error(`Invalid version "${version}". Expected semver (e.g. 1.6.0).`)
-    process.exitCode = 1
-    return
-  }
-
-  const packageEntries = await collectPackageEntries()
-
-  await Promise.all(
-    packageEntries.map(async (entry) => {
-      if (!existsSync(entry.pkgPath)) {
-        console.warn(
-          `${colors[entry.color ?? 'cyan']('●')} ${colors.yellow(
-            `Skipping missing package file: ${path.relative(rootDir, entry.pkgPath)}`,
-          )}`,
-        )
-        return
-      }
-      const raw = await readFile(entry.pkgPath, 'utf8')
-      const json = JSON.parse(raw)
-      const previousVersion = json.version ?? 'unknown'
-      json.version = version
-      const formatted = `${JSON.stringify(json, null, 2)}\n`
-      await writeFile(entry.pkgPath, formatted)
-      console.log(
-        `${colors[entry.color ?? 'cyan']('●')} ${colors.cyan('[sync]')} ${path.relative(rootDir, entry.pkgPath)} ${colors.dim(`${previousVersion} -> ${version}`)}`,
-      )
-    }),
-  )
-}
-
-main().catch((error) => {
-  console.error(error)
-  process.exitCode = 1
-})

package/src/utils/colors.ts

@@ -1,11 +0,0 @@
-// src/utils/colors.js
-const ansi = (code: number) => (text: string) => `\x1b[${code}m${text}\x1b[0m`
-export const colors = {
-  cyan: ansi(36),
-  green: ansi(32),
-  yellow: ansi(33),
-  magenta: ansi(35),
-  red: ansi(31),
-  bold: ansi(1),
-  dim: ansi(2),
-}

package/src/utils/log.ts

@@ -1,42 +0,0 @@
-// src/utils/log.js
-import { colors } from './colors.js'
-
-export type PackageColor = 'cyan' | 'green' | 'yellow' | 'magenta' | 'red'
-export const defaultPackageColor: PackageColor = 'cyan'
-export const globalEmoji = '🚀'
-
-export interface LoadedPackage {
-  dirName: string
-  path: string
-  packageJsonPath: string
-  json: Record<string, any>
-  version: string
-  name: string
-  color: PackageColor
-  substitute: string
-}
-
-export const formatPkgName = (pkg: LoadedPackage) => {
-  const primary = pkg.substitute
-  const displayName = pkg.name ?? pkg.dirName
-  const fileLabel = pkg.dirName
-  const colorizer = colors[pkg.color ?? defaultPackageColor]
-  return `${colorizer(colors.bold(primary))} ${colors.dim(
-    `(${displayName}) [${fileLabel}]`,
-  )}`
-}
-
-export const logPkg = (
-  pkg: LoadedPackage,
-  message: string,
-  colorizer = colors.cyan,
-) => {
-  const label = colors[pkg.color ?? defaultPackageColor](pkg.substitute)
-  console.log(`${label} ${colorizer(message)}`)
-}
-
-export const logGlobal = (message: string, colorizer = colors.magenta) => {
-  console.log(`${globalEmoji} ${colorizer(message)}`)
-}
-
-export { colors }