@wyxos/zephyr 0.1.1 → 0.1.2

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "scripts": {
-    "test": "vitest"
+    "test": "vitest",
+    "release": "node publish.mjs"
   },
   "bin": {
-    "zephyr": "./bin/zephyr.mjs"
+    "zephyr": "bin/zephyr.mjs"
   },
   "dependencies": {
     "chalk": "5.3.0",

package/publish.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import { readFile } from 'node:fs/promises'
+
+const ROOT = dirname(fileURLToPath(import.meta.url))
+const PACKAGE_PATH = join(ROOT, 'package.json')
+
+const STEP_PREFIX = '→'
+const OK_PREFIX = '✔'
+const WARN_PREFIX = '⚠'
+
+function logStep(message) {
+  console.log(`${STEP_PREFIX} ${message}`)
+}
+
+function logSuccess(message) {
+  console.log(`${OK_PREFIX} ${message}`)
+}
+
+function logWarning(message) {
+  console.warn(`${WARN_PREFIX} ${message}`)
+}
+
+function runCommand(command, args, { cwd = ROOT, capture = false } = {}) {
+  return new Promise((resolve, reject) => {
+    const spawnOptions = {
+      cwd,
+      stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit'
+    }
+
+    const child = spawn(command, args, spawnOptions)
+    let stdout = ''
+    let stderr = ''
+
+    if (capture) {
+      child.stdout.on('data', (chunk) => {
+        stdout += chunk
+      })
+
+      child.stderr.on('data', (chunk) => {
+        stderr += chunk
+      })
+    }
+
+    child.on('error', reject)
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve(capture ? { stdout: stdout.trim(), stderr: stderr.trim() } : undefined)
+      } else {
+        const error = new Error(`Command failed (${code}): ${command} ${args.join(' ')}`)
+        if (capture) {
+          error.stdout = stdout
+          error.stderr = stderr
+        }
+        error.exitCode = code
+        reject(error)
+      }
+    })
+  })
+}
+
+async function readPackage() {
+  const raw = await readFile(PACKAGE_PATH, 'utf8')
+  return JSON.parse(raw)
+}
+
+async function ensureCleanWorkingTree() {
+  const { stdout } = await runCommand('git', ['status', '--porcelain'], { capture: true })
+
+  if (stdout.length > 0) {
+    throw new Error('Working tree has uncommitted changes. Commit or stash them before releasing.')
+  }
+}
+
+async function getCurrentBranch() {
+  const { stdout } = await runCommand('git', ['branch', '--show-current'], { capture: true })
+  return stdout || null
+}
+
+async function getUpstreamRef() {
+  try {
+    const { stdout } = await runCommand('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], {
+      capture: true
+    })
+
+    return stdout || null
+  } catch {
+    return null
+  }
+}
+
+async function ensureUpToDateWithUpstream(branch, upstreamRef) {
+  if (!upstreamRef) {
+    logWarning(`Branch ${branch} has no upstream configured; skipping ahead/behind checks.`)
+    return
+  }
+
+  const aheadResult = await runCommand('git', ['rev-list', '--count', `${upstreamRef}..HEAD`], {
+    capture: true
+  })
+  const behindResult = await runCommand('git', ['rev-list', '--count', `HEAD..${upstreamRef}`], {
+    capture: true
+  })
+
+  const ahead = Number.parseInt(aheadResult.stdout || '0', 10)
+  const behind = Number.parseInt(behindResult.stdout || '0', 10)
+
+  if (Number.isFinite(behind) && behind > 0) {
+    throw new Error(
+      `Branch ${branch} is behind ${upstreamRef} by ${behind} commit${behind === 1 ? '' : 's'}. Pull or rebase first.`
+    )
+  }
+
+  if (Number.isFinite(ahead) && ahead > 0) {
+    logWarning(`Branch ${branch} is ahead of ${upstreamRef} by ${ahead} commit${ahead === 1 ? '' : 's'}.`)
+  }
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2)
+  const positionals = args.filter((arg) => !arg.startsWith('--'))
+  const flags = new Set(args.filter((arg) => arg.startsWith('--')))
+
+  const releaseType = positionals[0] ?? 'patch'
+  const skipTests = flags.has('--skip-tests')
+
+  const allowedTypes = new Set([
+    'major',
+    'minor',
+    'patch',
+    'premajor',
+    'preminor',
+    'prepatch',
+    'prerelease'
+  ])
+
+  if (!allowedTypes.has(releaseType)) {
+    throw new Error(
+      `Invalid release type "${releaseType}". Use one of: ${Array.from(allowedTypes).join(', ')}.`
+    )
+  }
+
+  return { releaseType, skipTests }
+}
+
+async function runTests(skipTests) {
+  if (skipTests) {
+    logWarning('Skipping tests because --skip-tests flag was provided.')
+    return
+  }
+
+  logStep('Running test suite (vitest run)...')
+  await runCommand('npx', ['vitest', 'run'])
+  logSuccess('Tests passed.')
+}
+
+async function ensureNpmAuth() {
+  logStep('Confirming npm authentication...')
+  await runCommand('npm', ['whoami'])
+}
+
+async function bumpVersion(releaseType) {
+  logStep(`Bumping package version with "npm version ${releaseType}"...`)
+  await runCommand('npm', ['version', releaseType, '--message', 'chore: release %s'])
+  const pkg = await readPackage()
+  logSuccess(`Version updated to ${pkg.version}.`)
+  return pkg
+}
+
+async function pushChanges() {
+  logStep('Pushing commits and tags to origin...')
+  await runCommand('git', ['push', '--follow-tags'])
+  logSuccess('Git push completed.')
+}
+
+async function publishPackage(pkg) {
+  const publishArgs = ['publish']
+
+  if (pkg.name.startsWith('@')) {
+    publishArgs.push('--access', 'public')
+  }
+
+  logStep(`Publishing ${pkg.name}@${pkg.version} to npm...`)
+  await runCommand('npm', publishArgs)
+  logSuccess('npm publish completed.')
+}
+
+async function main() {
+  const { releaseType, skipTests } = parseArgs()
+
+  logStep('Reading package metadata...')
+  const pkg = await readPackage()
+
+  logStep('Checking working tree status...')
+  await ensureCleanWorkingTree()
+
+  const branch = await getCurrentBranch()
+  if (!branch) {
+    throw new Error('Unable to determine current branch.')
+  }
+
+  logStep(`Current branch: ${branch}`)
+  const upstreamRef = await getUpstreamRef()
+  await ensureUpToDateWithUpstream(branch, upstreamRef)
+
+  await runTests(skipTests)
+  await ensureNpmAuth()
+
+  const updatedPkg = await bumpVersion(releaseType)
+  await pushChanges()
+  await publishPackage(updatedPkg)
+
+  logSuccess(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
+}
+
+main().catch((error) => {
+  console.error('\nRelease failed:')
+  console.error(error.message)
+  process.exit(1)
+})