@emeryld/manager 0.1.0

package/bin/manager-cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const packageRoot = path.resolve(__dirname, '..')
+const tsconfigPath = path.join(packageRoot, 'tsconfig.base.json')
+const entryPoint = path.join(packageRoot, 'src', 'publish.ts')
+
+const nodeArgs = ['--loader', 'ts-node/esm', entryPoint, ...process.argv.slice(2)]
+const execOptions = {
+  env: { ...process.env, TS_NODE_PROJECT: tsconfigPath },
+  stdio: 'inherit',
+}
+
+const child = spawnSync(process.execPath, nodeArgs, execOptions)
+if (child.error) throw child.error
+if (child.signal) {
+  process.kill(process.pid, child.signal)
+} else {
+  process.exit(child.status ?? 0)
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@emeryld/manager",
+  "version": "0.1.0",
+  "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "manager-cli": "bin/manager-cli.js"
+  },
+  "files": [
+    "src",
+    "bin",
+    "tsconfig.base.json",
+    "tsconfig.json"
+  ],
+  "keywords": [
+    "pnpm",
+    "monorepo",
+    "manager",
+    "release"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "semver": "^7.7.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.0"
+  },
+  "ts-node": {
+    "esm": true,
+    "project": "tsconfig.base.json",
+    "transpileOnly": true,
+    "swc": false
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.base.json",
+    "typecheck": "tsc -p tsconfig.base.json --noEmit"
+  }
+}

package/src/git.ts

@@ -0,0 +1,74 @@
+// src/git.ts
+import { spawn } from 'node:child_process'
+import { run } from './utils/run.ts'
+import { logGlobal, colors } from './utils/log.ts'
+import { rootDir } from './utils/run.ts'
+
+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

@@ -0,0 +1,379 @@
+import { spawn } from 'node:child_process'
+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 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 === '.ts' || extension === '.mts' || extension === '.cts'
+  const command = process.execPath
+  const execArgs = isTypeScript
+    ? ['--loader', 'ts-node/esm', 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

@@ -0,0 +1,142 @@
+// src/menu.ts
+import type { HelperScriptEntry } from './helper-cli.ts'
+import type { LoadedPackage } from './utils/log.ts'
+import { colors, globalEmoji } from './utils/log.ts'
+import {
+  updateDependencies,
+  testAll,
+  testSingle,
+  buildAll,
+  buildSingle,
+} from './workspace.ts'
+
+import { releaseMultiple, releaseSingle } from './release.ts'
+import { getOrderedPackages } from './packages.ts'
+import { runHelperCli } from './helper-cli.ts'
+import { ensureWorkingTreeCommitted } from './preflight.ts'
+
+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
+  }
+}