@emeryld/manager 0.2.0 → 0.2.2

package/src/git.ts

@@ -1,74 +0,0 @@
-// src/git.js
-import { spawn } from 'node:child_process'
-import { run } from './utils/run.js'
-import { logGlobal, colors } from './utils/log.js'
-import { rootDir } from './utils/run.js'
-
-export async function collectGitStatus(): Promise<string[]> {
-  return new Promise<string[]>((resolve, reject) => {
-    const child = spawn('git', ['status', '--porcelain'], {
-      cwd: rootDir,
-      stdio: ['ignore', 'pipe', 'inherit'],
-    })
-    const lines: string[] = []
-    child.stdout.on('data', (chunk) => {
-      lines.push(
-        ...chunk
-          .toString()
-          .split('\n')
-          // Preserve leading status markers; strip only trailing whitespace/newlines
-          .map((line: string) => line.replace(/\s+$/, ''))
-          .filter(Boolean),
-      )
-    })
-    child.on('error', reject)
-    child.on('close', (code) => {
-      if (code !== 0) return reject(new Error('Failed to read git status.'))
-      resolve(lines)
-    })
-  })
-}
-
-export async function gitAdd(paths: string[]) {
-  await run('git', ['add', ...paths])
-}
-
-export async function gitCommit(message: string) {
-  await run('git', ['commit', '-m', message])
-}
-
-export async function hasStagedChanges() {
-  return new Promise<boolean>((resolve, reject) => {
-    const child = spawn('git', ['diff', '--cached', '--quiet'], {
-      cwd: rootDir,
-      stdio: 'ignore',
-    })
-    child.on('close', (code) => {
-      if (code === 0) resolve(false)
-      else if (code === 1) resolve(true)
-      else reject(new Error('git diff --cached --quiet failed'))
-    })
-  })
-}
-
-export async function stageCommitPush(
-  changedPaths: string[],
-  commitMessage: string,
-) {
-  if (!changedPaths.length) {
-    logGlobal('No files changed; skipping commit.', colors.dim)
-    return
-  }
-  const unique = [...new Set(changedPaths)]
-  logGlobal('Staging files…', colors.cyan)
-  await gitAdd(unique)
-  const staged = await hasStagedChanges()
-  if (!staged) {
-    logGlobal('Nothing to commit; skipping commit/push.', colors.dim)
-    return
-  }
-  logGlobal('Creating commit…', colors.cyan)
-  await gitCommit(commitMessage)
-  logGlobal('Pushing to origin…', colors.cyan)
-  await run('git', ['push'])
-}

package/src/helper-cli.ts

@@ -1,405 +0,0 @@
-import { spawn } from 'node:child_process'
-import { createRequire } from 'node:module'
-import readline from 'node:readline/promises'
-import { stdin as input, stdout as output } from 'node:process'
-import { fileURLToPath } from 'node:url'
-import path from 'node:path'
-
-const __filename = fileURLToPath(import.meta.url)
-const rootDir = path.resolve(path.dirname(__filename), '..')
-const managerRequire = createRequire(import.meta.url)
-let tsNodeLoaderPath: string | undefined
-function getTsNodeLoaderPath() {
-  if (!tsNodeLoaderPath) {
-    tsNodeLoaderPath = managerRequire.resolve('ts-node/esm.mjs')
-  }
-  return tsNodeLoaderPath
-}
-
-export function buildTsNodeRegisterImport(scriptPath: string) {
-  const loader = getTsNodeLoaderPath()
-  const code = [
-    'import { register } from "node:module";',
-    'import { pathToFileURL } from "node:url";',
-    `register(${JSON.stringify(
-      loader,
-    )}, pathToFileURL(${JSON.stringify(scriptPath)}));`,
-  ].join(' ')
-  return `data:text/javascript,${encodeURIComponent(code)}`
-}
-
-const ansi = (code: number) => (text: string) => `\x1b[${code}m${text}\x1b[0m`
-const colors = {
-  cyan: ansi(36),
-  green: ansi(32),
-  yellow: ansi(33),
-  magenta: ansi(35),
-  dim: ansi(2),
-}
-
-export interface HelperScriptContext {
-  args: string[]
-  entry: NormalizedScriptEntry
-  rootDir: string
-}
-
-export type HelperScriptHandler = (
-  context: HelperScriptContext,
-) => Promise<void> | void
-
-export interface HelperScriptEntry {
-  name: string
-  emoji?: string
-  script?: string
-  description?: string
-  handler?: HelperScriptHandler
-}
-
-interface NormalizedScriptEntry extends HelperScriptEntry {
-  displayName: string
-  emoji: string
-  absoluteScript?: string
-  metaLabel: string
-  handler?: HelperScriptHandler
-}
-
-type ResolvedScriptEntry = NormalizedScriptEntry &
-  Required<Pick<NormalizedScriptEntry, 'metaLabel'>>
-
-function normalizeScripts(entries: HelperScriptEntry[]): ResolvedScriptEntry[] {
-  if (!Array.isArray(entries) || entries.length === 0) {
-    throw new Error('runHelperCli requires at least one script definition.')
-  }
-
-  return entries.map((entry, index) => {
-    if (!entry || typeof entry !== 'object') {
-      throw new Error(`Script entry at index ${index} is not an object.`)
-    }
-    if (!entry.name || typeof entry.name !== 'string') {
-      throw new Error(`Script entry at index ${index} is missing a "name".`)
-    }
-    const hasHandler = typeof entry.handler === 'function'
-    const hasScript =
-      typeof entry.script === 'string' && entry.script.length > 0
-    if (!hasHandler && !hasScript) {
-      throw new Error(
-        `Script "${entry.name}" requires either a "script" path or a "handler" function.`,
-      )
-    }
-    const absoluteScript =
-      hasScript && path.isAbsolute(entry.script!)
-        ? entry.script
-        : hasScript
-          ? path.join(rootDir, entry.script!)
-          : undefined
-    return {
-      ...entry,
-      emoji: entry.emoji ?? '🔧',
-      displayName: entry.name.trim(),
-      absoluteScript,
-      script: hasScript ? entry.script : undefined,
-      handler: hasHandler ? entry.handler : undefined,
-      metaLabel:
-        entry.description ?? (hasScript ? entry.script! : '[callback]'),
-    }
-  })
-}
-
-function findScriptEntry(
-  entries: ResolvedScriptEntry[],
-  key?: string,
-): ResolvedScriptEntry | undefined {
-  if (!key) return undefined
-  const normalized = key.toLowerCase()
-  return entries.find((entry) => {
-    const nameMatch = entry.displayName.toLowerCase() === normalized
-    const aliasMatch = entry.displayName.toLowerCase().includes(normalized)
-    const scriptMatch = entry.script
-      ? entry.script.toLowerCase().includes(normalized)
-      : false
-    return nameMatch || aliasMatch || scriptMatch
-  })
-}
-
-function printScriptList(entries: ResolvedScriptEntry[], title?: string) {
-  const heading = title
-    ? colors.magenta(title)
-    : colors.magenta('Available scripts')
-  console.log(heading)
-  entries.forEach((entry, index) => {
-    console.log(
-      `  ${colors.cyan(String(index + 1).padStart(2, ' '))} ${entry.emoji} ${entry.displayName} ${colors.dim(entry.metaLabel)}`,
-    )
-  })
-}
-
-async function promptWithReadline(
-  entries: ResolvedScriptEntry[],
-  title?: string,
-) {
-  printScriptList(entries, title)
-  const rl = readline.createInterface({ input, output })
-  try {
-    while (true) {
-      const answer = (
-        await rl.question(colors.cyan('\nSelect a script by number or name: '))
-      ).trim()
-      if (!answer) continue
-      const numeric = Number.parseInt(answer, 10)
-      if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= entries.length) {
-        return entries[numeric - 1]
-      }
-      const byName = findScriptEntry(entries, answer)
-      if (byName) return byName
-      console.log(colors.yellow(`Could not find "${answer}". Try again.`))
-    }
-  } finally {
-    rl.close()
-  }
-}
-
-function formatInteractiveLines(
-  entries: ResolvedScriptEntry[],
-  selectedIndex: number,
-  title?: string,
-) {
-  const heading = title
-    ? colors.magenta(title)
-    : colors.magenta('Available scripts')
-  const lines = [heading]
-  entries.forEach((entry, index) => {
-    const isSelected = index === selectedIndex
-    const pointer = isSelected ? `${colors.green('➤')} ` : ''
-    const numberLabel = colors.cyan(`${index + 1}`.padStart(2, ' '))
-    const label = isSelected
-      ? colors.green(entry.displayName)
-      : entry.displayName
-    lines.push(
-      `${pointer}${numberLabel}. ${entry.emoji} ${label} ${colors.dim(entry.metaLabel)}`,
-    )
-  })
-  lines.push('')
-  lines.push(
-    colors.dim(
-      'Use ↑/↓ (or j/k) to move, digits (1-9,0 for 10) to run instantly, Enter to confirm, Esc/Ctrl+C to exit.',
-    ),
-  )
-  return lines
-}
-
-function renderInteractiveList(lines: string[], previousLineCount: number) {
-  if (previousLineCount > 0) {
-    process.stdout.write(`\x1b[${previousLineCount}A`)
-    process.stdout.write('\x1b[0J')
-  }
-  lines.forEach((line) => console.log(line))
-  return lines.length
-}
-
-async function promptForScript(entries: ResolvedScriptEntry[], title?: string) {
-  const supportsRawMode = typeof input.setRawMode === 'function' && input.isTTY
-  if (!supportsRawMode) {
-    return promptWithReadline(entries, title)
-  }
-  const wasRaw = input.isRaw
-  if (!wasRaw) {
-    input.setRawMode(true)
-    input.resume()
-  }
-  process.stdout.write('\x1b[?25l')
-
-  return new Promise<ResolvedScriptEntry>((resolve) => {
-    let selectedIndex = 0
-    let renderedLines = 0
-
-    const cleanup = () => {
-      if (renderedLines > 0) {
-        process.stdout.write(`\x1b[${renderedLines}A`)
-        process.stdout.write('\x1b[0J')
-        renderedLines = 0
-      }
-      process.stdout.write('\x1b[?25h')
-      if (!wasRaw) {
-        input.setRawMode(false)
-        input.pause()
-      }
-      input.removeListener('data', onData)
-    }
-
-    const commitSelection = (entry: ResolvedScriptEntry) => {
-      cleanup()
-      console.log()
-      resolve(entry)
-    }
-
-    const render = () => {
-      const lines = formatInteractiveLines(entries, selectedIndex, title)
-      renderedLines = renderInteractiveList(lines, renderedLines)
-    }
-
-    const onData = (buffer: Buffer) => {
-      const isArrowUp = buffer.equals(Buffer.from([0x1b, 0x5b, 0x41]))
-      const isArrowDown = buffer.equals(Buffer.from([0x1b, 0x5b, 0x42]))
-      const isCtrlC = buffer.length === 1 && buffer[0] === 0x03
-      const isEnter =
-        buffer.length === 1 && (buffer[0] === 0x0d || buffer[0] === 0x0a)
-      const isEscape = buffer.length === 1 && buffer[0] === 0x1b
-
-      if (isCtrlC || isEscape) {
-        cleanup()
-        process.exit(1)
-      }
-
-      if (
-        isArrowUp ||
-        (buffer.length === 1 && (buffer[0] === 0x6b || buffer[0] === 0x4b))
-      ) {
-        selectedIndex = (selectedIndex - 1 + entries.length) % entries.length
-        render()
-        return
-      }
-      if (
-        isArrowDown ||
-        (buffer.length === 1 && (buffer[0] === 0x6a || buffer[0] === 0x4a))
-      ) {
-        selectedIndex = (selectedIndex + 1) % entries.length
-        render()
-        return
-      }
-
-      if (isEnter) {
-        commitSelection(entries[selectedIndex])
-        return
-      }
-
-      if (buffer.length === 1 && buffer[0] >= 0x30 && buffer[0] <= 0x39) {
-        const numericValue = buffer[0] === 0x30 ? 10 : buffer[0] - 0x30
-        const selected = numericValue - 1
-        if (selected >= 0 && selected < entries.length) {
-          commitSelection(entries[selected])
-        } else {
-          process.stdout.write('\x07')
-        }
-        return
-      }
-
-      if (
-        buffer.length === 1 &&
-        ((buffer[0] >= 0x41 && buffer[0] <= 0x5a) ||
-          (buffer[0] >= 0x61 && buffer[0] <= 0x7a))
-      ) {
-        const char = String.fromCharCode(buffer[0]).toLowerCase()
-        const foundIndex = entries.findIndex((entry) =>
-          entry.displayName.toLowerCase().startsWith(char),
-        )
-        if (foundIndex !== -1) {
-          selectedIndex = foundIndex
-          render()
-        } else {
-          process.stdout.write('\x07')
-        }
-      }
-    }
-
-    input.on('data', onData)
-    render()
-  })
-}
-
-function runEntry(entry: ResolvedScriptEntry, forwardedArgs: string[]) {
-  const detail = entry.script
-    ? path.relative(rootDir, entry.absoluteScript ?? entry.script)
-    : (entry.metaLabel ?? '[callback]')
-  console.log(
-    `${entry.emoji} ${colors.green(`Running "${entry.displayName}"`)} ${colors.dim(detail)}`,
-  )
-  if (entry.handler) {
-    return Promise.resolve(
-      entry.handler({ args: forwardedArgs, entry, rootDir }),
-    )
-  }
-  if (!entry.absoluteScript) {
-    throw new Error(`Script "${entry.displayName}" is missing a resolved path.`)
-  }
-  const scriptPath = entry.absoluteScript
-  const tsConfigPath = path.join(rootDir, 'tsconfig.base.json')
-  const extension = path.extname(scriptPath).toLowerCase()
-  const isTypeScript = extension === '.js' || extension === '.mts' || extension === '.cts'
-  const command = process.execPath
-  const execArgs = isTypeScript
-    ? [
-        '--import',
-        buildTsNodeRegisterImport(scriptPath),
-        scriptPath,
-        ...forwardedArgs,
-      ]
-    : [scriptPath, ...forwardedArgs]
-  return new Promise<void>((resolve, reject) => {
-    const child = spawn(command, execArgs, {
-      cwd: rootDir,
-      stdio: 'inherit',
-      env: isTypeScript
-        ? { ...process.env, TS_NODE_PROJECT: tsConfigPath }
-        : process.env,
-      shell: process.platform === 'win32' && isTypeScript,
-    })
-    child.on('close', (code) => {
-      if (code === 0) resolve()
-      else
-        reject(
-          new Error(`Script "${entry.displayName}" exited with code ${code}`),
-        )
-    })
-  })
-}
-
-export interface HelperCliOptions {
-  scripts: HelperScriptEntry[]
-  title?: string
-  argv?: string[]
-}
-
-export async function runHelperCli({
-  scripts,
-  title = 'Helper CLI',
-  argv = process.argv.slice(2),
-}: HelperCliOptions) {
-  const normalized = normalizeScripts(scripts)
-  let args = Array.isArray(argv) ? [...argv] : []
-  const separatorIndex = args.indexOf('--')
-  if (separatorIndex !== -1) {
-    args = [...args.slice(0, separatorIndex), ...args.slice(separatorIndex + 1)]
-  }
-  const [firstArg, ...restArgs] = args
-
-  if (firstArg === '--list' || firstArg === '-l') {
-    printScriptList(normalized, title)
-    return
-  }
-
-  if (firstArg === '--help' || firstArg === '-h') {
-    console.log(colors.magenta('Usage:'))
-    console.log('  pnpm run <cli> [script] [...args]')
-    console.log('\nFlags:')
-    console.log('  --list  Show available scripts')
-    console.log('  --help  Show this information')
-    return
-  }
-
-  const argLooksLikeScript = firstArg && !firstArg.startsWith('-')
-  if (argLooksLikeScript) {
-    const requested = findScriptEntry(normalized, firstArg)
-    if (requested) {
-      await runEntry(requested, restArgs)
-      return
-    }
-    console.log(
-      colors.yellow(
-        `Unknown script "${firstArg}". Falling back to interactive selection…`,
-      ),
-    )
-  }
-
-  const selection = await promptForScript(normalized, title)
-  await runEntry(selection, [])
-}

package/src/menu.ts

@@ -1,142 +0,0 @@
-// src/menu.js
-import type { HelperScriptEntry } from './helper-cli.js'
-import type { LoadedPackage } from './utils/log.js'
-import { colors, globalEmoji } from './utils/log.js'
-import {
-  updateDependencies,
-  testAll,
-  testSingle,
-  buildAll,
-  buildSingle,
-} from './workspace.js'
-
-import { releaseMultiple, releaseSingle } from './release.js'
-import { getOrderedPackages } from './packages.js'
-import { runHelperCli } from './helper-cli.js'
-import { ensureWorkingTreeCommitted } from './preflight.js'
-
-export type StepKey = 'update' | 'test' | 'build' | 'publish' | 'full' | 'back'
-
-export function makeStepEntries(
-  targets: LoadedPackage[],
-  packages: LoadedPackage[],
-  state: { lastStep?: StepKey },
-): HelperScriptEntry[] {
-  return [
-    {
-      name: 'update dependencies',
-      emoji: '♻️',
-      description: 'Update dependencies for the selection',
-      handler: async () => {
-        await updateDependencies(targets)
-        state.lastStep = 'update'
-      },
-    },
-    {
-      name: 'test',
-      emoji: '🧪',
-      description: 'Run tests',
-      handler: async () => {
-        if (targets.length === 1) await testSingle(targets[0])
-        else await testAll()
-        state.lastStep = 'test'
-      },
-    },
-    {
-      name: 'build',
-      emoji: '🏗️',
-      description: 'Build packages',
-      handler: async () => {
-        if (targets.length === 1) await buildSingle(targets[0])
-        else await buildAll()
-        state.lastStep = 'build'
-      },
-    },
-    {
-      name: 'publish',
-      emoji: '🚀',
-      description: 'Version, commit, and publish',
-      handler: async () => {
-        await ensureWorkingTreeCommitted()
-        if (targets.length > 1) await releaseMultiple(targets, packages)
-        else await releaseSingle(targets[0], packages)
-        state.lastStep = 'publish'
-      },
-    },
-    {
-      name: 'full',
-      emoji: '✅',
-      description: 'update → test → build → publish',
-      handler: async () => {
-        await updateDependencies(targets)
-        if (targets.length === 1) await testSingle(targets[0])
-        else await testAll()
-        if (targets.length === 1) await buildSingle(targets[0])
-        else await buildAll()
-        await ensureWorkingTreeCommitted()
-        if (targets.length > 1) await releaseMultiple(targets, packages)
-        else await releaseSingle(targets[0], packages)
-        state.lastStep = 'full'
-      },
-    },
-    {
-      name: 'back',
-      emoji: '↩️',
-      description: 'Pick packages again',
-      handler: async () => {
-        state.lastStep = 'back'
-      },
-    },
-  ]
-}
-
-export function buildPackageSelectionMenu(
-  packages: LoadedPackage[],
-  onStepComplete?: (lastStep?: StepKey) => void,
-): HelperScriptEntry[] {
-  const ordered = getOrderedPackages(packages)
-  const entries = ordered.map((pkg) => ({
-    name: pkg.substitute,
-    emoji: colors[pkg.color]('●'),
-    description: pkg.name ?? pkg.dirName,
-    handler: async () => {
-      const step = await runStepLoop([pkg], packages)
-      onStepComplete?.(step)
-    },
-  }))
-  entries.push({
-    name: 'All packages',
-    emoji: globalEmoji,
-    description: 'Select all packages',
-    handler: async () => {
-      const step = await runStepLoop(ordered, packages)
-      onStepComplete?.(step)
-    },
-  })
-  return entries
-}
-
-// IMPORTANT FIX: do not auto-pass argv derived from lastStep.
-// This removes the infinite loop and returns to the step menu after each run.
-export async function runStepLoop(
-  targets: LoadedPackage[],
-  packages: LoadedPackage[],
-): Promise<StepKey | undefined> {
-  const state: { lastStep?: StepKey } = {}
-  // Loop shows the step menu and executes a chosen action once.
-  // After the handler completes, show the menu again.
-  // Selecting "back" breaks and returns control to the package picker.
-  // No argv auto-execution here.
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    state.lastStep = undefined
-    const entries = makeStepEntries(targets, packages, state)
-    await runHelperCli({
-      title: `Actions for ${targets.length === 1 ? targets[0].name : 'selected packages'}`,
-      scripts: entries,
-      argv: [], // <- key change
-    })
-    if (state.lastStep === 'back') return state.lastStep
-    // keep looping to show menu again
-  }
-}