@emeryld/manager 0.2.0 → 0.2.2

package/src/packages.ts

@@ -1,305 +0,0 @@
-// src/packages.js
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import { readdir, readFile } from 'node:fs/promises'
-import type { PackageColor, LoadedPackage } from './utils/log.js'
-
-const rootDir = process.cwd()
-export const packagesDir = path.join(rootDir, 'packages')
-
-type ManifestEntry = {
-  name: string
-  path: string
-  color?: PackageColor
-  substitute?: string
-}
-
-type ManifestState = {
-  entries: ManifestEntry[]
-  byName: Map<string, ManifestEntry>
-  byPath: Map<string, ManifestEntry>
-  orderedPackagePaths: string[]
-}
-
-const colorPalette: PackageColor[] = ['cyan', 'green', 'yellow', 'magenta', 'red']
-let manifestState: ManifestState | undefined
-
-function manifestFilePath() {
-  return path.join(rootDir, 'scripts', 'packages.mjs')
-}
-
-function isManifestMissing(error: unknown) {
-  if (typeof error !== 'object' || error === null) return false
-  const code = (error as { code?: string }).code
-  return code === 'ERR_MODULE_NOT_FOUND' || code === 'ENOENT'
-}
-
-function normalizeManifestPath(value: string) {
-  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: string) {
-  const normalized = `${seed}`.trim() || 'package'
-  let hash = 0
-  for (let i = 0; i < normalized.length; i++) {
-    hash = (hash * 31 + normalized.charCodeAt(i)) >>> 0
-  }
-  return colorPalette[hash % colorPalette.length]
-}
-
-function deriveSubstitute(name: string) {
-  const trimmed = (name || '').trim()
-  if (!trimmed) return ''
-  const segments = trimmed.split(/[@\/\-]/).filter(Boolean)
-  const transformed = segments
-    .map((segment) => segment.slice(0, 2))
-    .filter(Boolean)
-    .join(' ')
-  return transformed || trimmed
-}
-
-async function loadWorkspaceManifest(): Promise<ManifestEntry[] | undefined> {
-  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(): Promise<ManifestEntry[]> {
-  try {
-    const entries = await readdir(packagesDir, { withFileTypes: true })
-    const manifest: ManifestEntry[] = []
-    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) as { name?: string }
-        const pkgName = json.name?.trim() || entry.name
-        manifest.push({
-          name: pkgName,
-          path: normalizeManifestPath(path.relative(rootDir, path.join(packagesDir, entry.name))),
-          color: colorFromSeed(pkgName),
-          substitute: deriveSubstitute(pkgName),
-        })
-      } catch {
-        continue
-      }
-    }
-    return manifest
-  } catch {
-    return []
-  }
-}
-
-function mergeManifestEntries(
-  inferred: ManifestEntry[],
-  overrides?: ManifestEntry[],
-) {
-  const normalizedOverrides = new Map<string, ManifestEntry>()
-  overrides?.forEach((entry) => {
-    const normalized = normalizeManifestPath(entry.path)
-    if (!normalized) return
-    normalizedOverrides.set(normalized, { ...entry, path: normalized })
-  })
-
-  const merged: ManifestEntry[] = []
-  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)
-      const substitute =
-        override.substitute ?? baseEntry.substitute ?? deriveSubstitute(name) ?? name
-      merged.push({ name, path: normalized, color, substitute })
-    } else {
-      merged.push({ ...baseEntry, path: normalized })
-    }
-  }
-
-  normalizedOverrides.forEach((entry) => {
-    const name = entry.name || path.basename(entry.path) || 'package'
-    const color = entry.color ?? colorFromSeed(name)
-    const substitute = entry.substitute ?? deriveSubstitute(name) ?? name
-    merged.push({ name, path: entry.path, color, substitute })
-  })
-
-  return merged
-}
-
-async function ensureManifestState() {
-  if (manifestState) return manifestState
-  const [workspaceManifest, inferred] = await Promise.all([
-    loadWorkspaceManifest(),
-    inferManifestFromWorkspace(),
-  ])
-  const entries = mergeManifestEntries(inferred, workspaceManifest)
-  const byName = new Map(entries.map((pkg) => [pkg.name.toLowerCase(), pkg]))
-  const byPath = new Map(entries.map((pkg) => [pkg.path.toLowerCase(), pkg]))
-  manifestState = {
-    entries,
-    byName,
-    byPath,
-    orderedPackagePaths: entries.map((pkg) => pkg.path.toLowerCase()),
-  }
-  return manifestState
-}
-
-export async function loadPackages(): Promise<LoadedPackage[]> {
-  const entries = await readdir(packagesDir, { withFileTypes: true })
-  const packages: LoadedPackage[] = []
-  const { byName, byPath } = await ensureManifestState()
-  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 as string | undefined) ?? entry.name
-      const relativePath = normalizeManifestPath(
-        path.relative(rootDir, path.join(packagesDir, entry.name)),
-      )
-      const meta =
-        byPath.get(relativePath.toLowerCase()) ??
-        byName.get(pkgName.toLowerCase())
-      const substitute =
-        meta?.substitute ?? deriveSubstitute(pkgName) ?? entry.name
-      const color = meta?.color ?? colorFromSeed(pkgName)
-      packages.push({
-        dirName: entry.name,
-        path: path.join(packagesDir, entry.name),
-        packageJsonPath: pkgJsonPath,
-        json,
-        version: json.version,
-        name: pkgName,
-        substitute,
-        color,
-      })
-    } catch (error) {
-      console.warn(`Skipping ${entry.name}: ${error}`)
-    }
-  }
-  return packages
-}
-
-export function resolvePackage(packages: LoadedPackage[], key?: string) {
-  if (!key) return undefined
-  const normalized = key.toLowerCase()
-  return packages.find((pkg) => {
-    const dirMatch = pkg.dirName.toLowerCase() === normalized
-    const nameMatch = (pkg.name ?? '').toLowerCase() === normalized
-    const aliasMatch = (pkg.substitute ?? '').toLowerCase() === normalized
-    const fuzzyMatch = (pkg.name ?? '').toLowerCase().includes(normalized)
-    return dirMatch || nameMatch || aliasMatch || fuzzyMatch
-  })
-}
-
-/**
- * Topologically sort by internal dependencies.
- * Falls back to manifest order for ties to preserve stability.
- */
-export function getOrderedPackages(packages: LoadedPackage[]) {
-  if (packages.length <= 1) return [...packages]
-
-  // Build lookup by package name
-  const byName = new Map<string, LoadedPackage>()
-  const byDir = new Map<string, LoadedPackage>()
-  for (const p of packages) {
-    if (p.name) byName.set(p.name, p)
-    byDir.set(p.dirName, p)
-  }
-
-  // Build adjacency list: edge dep -> pkg (dep must publish first)
-  const depsOf = (p: LoadedPackage) => {
-    const j = p.json ?? {}
-    const fields = [
-      'dependencies',
-      'devDependencies',
-      'peerDependencies',
-    ] as const
-    const names = new Set<string>()
-    for (const f of fields) {
-      const obj = j[f] as Record<string, string> | undefined
-      if (!obj) continue
-      for (const k of Object.keys(obj)) names.add(k)
-    }
-    return [...names]
-      .map((n) => byName.get(n))
-      .filter((x): x is LoadedPackage => Boolean(x))
-  }
-
-  const nodes = new Set(packages.map((p) => p.dirName))
-  const inDegree = new Map<string, number>()
-  const adj = new Map<string, Set<string>>()
-  for (const p of packages) {
-    inDegree.set(p.dirName, 0)
-    adj.set(p.dirName, new Set())
-  }
-  for (const p of packages) {
-    for (const dep of depsOf(p)) {
-      // dep -> p
-      if (!nodes.has(dep.dirName)) continue
-      if (dep.dirName === p.dirName) continue
-      const set = adj.get(dep.dirName)!
-      if (!set.has(p.dirName)) {
-        set.add(p.dirName)
-        inDegree.set(p.dirName, (inDegree.get(p.dirName) ?? 0) + 1)
-      }
-    }
-  }
-
-  // Kahn's algorithm with stable tie-break using manifest order then alpha
-  const orderedFiles = manifestState?.orderedPackagePaths ?? []
-  const priorityIndex = new Map<string, number>()
-  orderedFiles.forEach((file, i) => priorityIndex.set(file, i))
-  const pickOrder = (a: string, b: string) => {
-    const pa = priorityIndex.get(a) ?? Number.MAX_SAFE_INTEGER
-    const pb = priorityIndex.get(b) ?? Number.MAX_SAFE_INTEGER
-    if (pa !== pb) return pa - pb
-    return a.localeCompare(b)
-  }
-
-  const queue = [
-    ...[...nodes].filter((n) => (inDegree.get(n) ?? 0) === 0),
-  ].sort(pickOrder)
-  const result: string[] = []
-  while (queue.length) {
-    const n = queue.shift()!
-    result.push(n)
-    for (const m of adj.get(n)!) {
-      inDegree.set(m, (inDegree.get(m) ?? 0) - 1)
-      if ((inDegree.get(m) ?? 0) === 0) {
-        // insert keeping order
-        const idx = queue.findIndex((x) => pickOrder(m, x) < 0)
-        if (idx === -1) queue.push(m)
-        else queue.splice(idx, 0, m)
-      }
-    }
-  }
-
-  // If cycle, append remaining in original manifest order
-  const remaining = [...nodes]
-    .filter((n) => !result.includes(n))
-    .sort(pickOrder)
-  const orderedDirNames = [...result, ...remaining]
-  const ordered = orderedDirNames
-    .map((d) => byDir.get(d))
-    .filter((p): p is LoadedPackage => Boolean(p))
-
-  // Keep any not in the set at the end (shouldn't happen)
-  const tail = packages.filter((p) => !ordered.includes(p))
-  return [...ordered, ...tail]
-}

package/src/preflight.ts

@@ -1,26 +0,0 @@
-// src/preflight.js
-import { collectGitStatus } from './git.js'
-
-import { colors, logGlobal } from './utils/log.js'
-import { run } from './utils/run.js'
-import { gitAdd, gitCommit } from './git.js'
-import { askLine } from './prompts.js'
-
-export async function ensureWorkingTreeCommitted() {
-  const changes = await collectGitStatus()
-  if (changes.length === 0) return
-  logGlobal('Detected pending git changes:', colors.yellow)
-  changes.forEach((line) => console.log(colors.dim(` • ${line}`)))
-  let message = ''
-  while (!message) {
-    // eslint-disable-next-line no-await-in-loop
-    message = await askLine('Enter commit message to capture current changes: ')
-    if (!message) console.log(colors.red('Commit message cannot be empty.'))
-  }
-  logGlobal('Staging existing changes…', colors.cyan)
-  await run('git', ['add', '--all'])
-  logGlobal('Creating commit…', colors.cyan)
-  await gitCommit(message)
-  logGlobal('Pushing commit…', colors.cyan)
-  await run('git', ['push'])
-}

package/src/prompts.ts

@@ -1,93 +0,0 @@
-// src/prompts.js
-import readline from 'node:readline/promises'
-import { stdin as input, stdout as output } from 'node:process'
-import { colors } from './utils/log.js'
-
-export type YesNoAll = 'yes' | 'no' | 'all'
-
-export const publishCliState = { autoConfirmAll: false }
-
-export function promptSingleKey<T>(
-  message: string,
-  resolver: (key: string, raw: string) => T | undefined,
-) {
-  const supportsRawMode = typeof input.setRawMode === 'function' && input.isTTY
-  if (!supportsRawMode) {
-    return (async () => {
-      const rl = readline.createInterface({ input, output })
-      try {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-          const answer = (await rl.question(message)).trim()
-          const key = answer.toLowerCase()
-          const result = resolver(key, answer)
-          if (result !== undefined) return result
-        }
-      } finally {
-        rl.close()
-      }
-    })()
-  }
-
-  return new Promise<T>((resolve) => {
-    const wasRaw = input.isRaw
-    if (!wasRaw) {
-      input.setRawMode(true)
-      input.resume()
-    }
-    process.stdout.write(message)
-    const onData = (buffer: Buffer) => {
-      const str = buffer.toString()
-      if (str === '\u0003') {
-        process.stdout.write('\n')
-        process.exit(1)
-      }
-      const key = str.toLowerCase()
-      const result = resolver(key, str)
-      if (result !== undefined) {
-        process.stdout.write('\n')
-        cleanup()
-        resolve(result)
-      }
-    }
-    const cleanup = () => {
-      input.off('data', onData)
-      if (!wasRaw) {
-        input.setRawMode(false)
-        input.pause()
-      }
-    }
-    input.on('data', onData)
-  })
-}
-
-export async function askLine(question: string) {
-  const rl = readline.createInterface({ input, output })
-  try {
-    const answer = await rl.question(question)
-    return answer.trim()
-  } finally {
-    rl.close()
-  }
-}
-
-export async function promptYesNoAll(question: string): Promise<YesNoAll> {
-  if (publishCliState.autoConfirmAll) {
-    console.log(`${question} (auto-confirmed via "all")`)
-    return 'yes'
-  }
-  const result = await promptSingleKey<YesNoAll>(
-    `${question} (y/n/a): `,
-    (key) => {
-      if (key === 'y') return 'yes'
-      if (key === 'n') return 'no'
-      if (key === 'a') return 'all'
-      return undefined
-    },
-  )
-  if (result === 'all') {
-    publishCliState.autoConfirmAll = true
-    return 'yes'
-  }
-  return result
-}

package/src/publish.ts

@@ -1,183 +0,0 @@
-// src/publish.js
-import { runHelperCli } from './helper-cli.js'
-import { buildPackageSelectionMenu, runStepLoop, type StepKey } from './menu.js'
-import { getOrderedPackages, loadPackages, resolvePackage } from './packages.js'
-import {
-  releaseMultiple,
-  releaseSingle,
-  type PublishOptions,
-} from './release.js'
-import { ensureWorkingTreeCommitted } from './preflight.js'
-import { publishCliState } from './prompts.js'
-
-type Parsed = {
-  selectionArg?: string
-  helperArgs: string[]
-  // non-interactive publish options
-  nonInteractive: boolean
-  bumpType?: 'patch' | 'minor' | 'major'
-  syncVersion?: string
-  tag?: string
-  dryRun?: boolean
-  provenance?: boolean
-  noop?: boolean
-}
-
-function resolveTargetsFromArg(
-  packages: Awaited<ReturnType<typeof loadPackages>>,
-  arg: string,
-) {
-  if (arg.toLowerCase() === 'all') return getOrderedPackages(packages)
-  const pkg = resolvePackage(packages, arg)
-  if (!pkg) throw new Error(`Package "${arg}" not found.`)
-  return [pkg]
-}
-
-function parseCliArgs(args: string[]): Parsed {
-  let selectionArg: string | undefined
-  const helperArgs: string[] = []
-
-  let nonInteractive = false
-  let bumpType: Parsed['bumpType']
-  let syncVersion: string | undefined
-  let tag: string | undefined
-  let dryRun = false
-  let provenance = false
-  let noop = false
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]
-
-    // selectionArg is the first non-flag token
-    if (!selectionArg && !arg.startsWith('-')) {
-      selectionArg = arg
-      helperArgs.push(arg)
-      continue
-    }
-
-    if (
-      arg === '--yes' ||
-      arg === '-y' ||
-      arg === '--non-interactive' ||
-      arg === '--ci'
-    ) {
-      nonInteractive = true
-      continue
-    }
-    if (arg === '--bump') {
-      bumpType = args[++i] as Parsed['bumpType']
-      continue
-    }
-    if (arg === '--sync') {
-      syncVersion = args[++i]
-      continue
-    }
-    if (arg === '--tag') {
-      tag = args[++i]
-      continue
-    }
-    if (arg === '--dry-run') {
-      dryRun = true
-      continue
-    }
-    if (arg === '--provenance') {
-      provenance = true
-      continue
-    }
-    if (arg === '--noop') {
-      noop = true
-      continue
-    }
-
-    // pass-through for helper CLI
-    helperArgs.push(arg)
-  }
-
-  return {
-    selectionArg,
-    helperArgs,
-    nonInteractive,
-    bumpType,
-    syncVersion,
-    tag,
-    dryRun,
-    provenance,
-    noop,
-  }
-}
-
-function optsFromParsed(p: Parsed): PublishOptions {
-  return {
-    nonInteractive: p.nonInteractive,
-    bumpType: p.bumpType,
-    syncVersion: p.syncVersion,
-    tag: p.tag,
-    dryRun: p.dryRun,
-    provenance: p.provenance,
-  }
-}
-
-async function runPackageSelectionLoop(
-  packages: Awaited<ReturnType<typeof loadPackages>>,
-  helperArgs: string[],
-) {
-  let argv = [...helperArgs]
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    let lastStep: StepKey | undefined
-    await runHelperCli({
-      title: 'Pick one of the packages or all',
-      scripts: buildPackageSelectionMenu(packages, (step) => {
-        lastStep = step
-      }),
-      argv, // pass through CLI args only once; subsequent loops rely on selection
-    })
-    argv = []
-    if (lastStep !== 'back') return
-  }
-}
-
-async function main(): Promise<void> {
-  const cliArgs = process.argv.slice(2)
-  const parsed = parseCliArgs(cliArgs)
-  const packages = await loadPackages()
-  if (packages.length === 0) throw new Error('No packages found in ./packages')
-
-  // If user provided non-interactive flags, run headless path
-  if (parsed.nonInteractive) {
-    publishCliState.autoConfirmAll = true
-
-    if (!parsed.selectionArg) {
-      throw new Error(
-        'Non-interactive mode requires a package selection: <pkg> or "all".',
-      )
-    }
-    if (!parsed.bumpType && !parsed.syncVersion && !parsed.noop) {
-      throw new Error(
-        'Non-interactive mode requires one of: --bump <type> | --sync <version> | --noop',
-      )
-    }
-
-    const targets = resolveTargetsFromArg(packages, parsed.selectionArg)
-    const opts = optsFromParsed(parsed)
-
-    await ensureWorkingTreeCommitted()
-    if (targets.length > 1) await releaseMultiple(targets, packages, opts)
-    else await releaseSingle(targets[0], packages, opts)
-    return
-  }
-
-  // Interactive flow (unchanged): selection menu then step menu
-  if (parsed.selectionArg) {
-    const targets = resolveTargetsFromArg(packages, parsed.selectionArg)
-    await runStepLoop(targets, packages)
-    return
-  }
-
-  await runPackageSelectionLoop(packages, parsed.helperArgs)
-}
-
-main().catch((error) => {
-  console.error(error)
-  process.exit(1)
-})