@wyxos/zephyr 0.4.9 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "A streamlined deployment tool for web applications with intelligent Laravel project detection",
   "type": "module",
   "main": "./src/index.mjs",

package/src/application/release/release-node-package.mjs

@@ -11,6 +11,7 @@ import {
     runReleaseCommand,
     validateReleaseDependencies
 } from '../../release/shared.mjs'
+import {resolveReleaseType} from '../../release/release-type.mjs'
 import {gitCommitArgs, gitPushArgs, npmVersionArgs} from '../../utils/git-hooks.mjs'
 
 async function readPackage(rootDir = process.cwd()) {
@@ -392,12 +393,23 @@ export async function releaseNodePackage({
         skipGitHooks
     })
     await ensureReleaseBranchReady({rootDir, branchMethod: 'show-current', logStep, logWarning})
+    const resolvedReleaseType = await resolveReleaseType({
+        releaseType,
+        currentVersion: pkg.version,
+        packageName: pkg.name,
+        rootDir,
+        interactive,
+        runPrompt,
+        runCommand,
+        logStep,
+        logWarning
+    })
 
     await runLint(skipLint, pkg, rootDir, {logStep, logSuccess, logWarning, runCommand})
     await runTests(skipTests, pkg, rootDir, {logStep, logSuccess, logWarning, runCommand})
     await runLibBuild(skipBuild, pkg, rootDir, {logStep, logSuccess, logWarning, runCommand, skipGitHooks})
 
-    const updatedPkg = await bumpVersion(releaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
+    const updatedPkg = await bumpVersion(resolvedReleaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
     await runBuild(skipBuild, updatedPkg, rootDir, {logStep, logSuccess, logWarning, runCommand})
     await pushChanges(rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
     await deployGHPages(skipDeploy, updatedPkg, rootDir, {logStep, logSuccess, logWarning, runCommand, skipGitHooks})

package/src/application/release/release-packagist-package.mjs

@@ -11,6 +11,7 @@ import {
     runReleaseCommand,
     validateReleaseDependencies
 } from '../../release/shared.mjs'
+import {resolveReleaseType} from '../../release/release-type.mjs'
 import {gitCommitArgs, gitPushArgs} from '../../utils/git-hooks.mjs'
 
 async function readComposer(rootDir = process.cwd()) {
@@ -259,11 +260,22 @@ export async function releasePackagistPackage({
         skipGitHooks
     })
     await ensureReleaseBranchReady({rootDir, branchMethod: 'show-current', logStep, logWarning})
+    const resolvedReleaseType = await resolveReleaseType({
+        releaseType,
+        currentVersion: composer.version,
+        packageName: composer.name,
+        rootDir,
+        interactive,
+        runPrompt,
+        runCommand,
+        logStep,
+        logWarning
+    })
 
     await runLint(skipLint, rootDir, {logStep, logSuccess, logWarning, runCommand, progressWriter})
     await runTests(skipTests, composer, rootDir, {logStep, logSuccess, logWarning, runCommand, progressWriter})
 
-    const updatedComposer = await bumpVersion(releaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
+    const updatedComposer = await bumpVersion(resolvedReleaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
     await pushChanges(rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
 
     logSuccess?.(`Release workflow completed for ${composer.name}@${updatedComposer.version}.`)

package/src/release/release-type.mjs

@@ -0,0 +1,293 @@
+import {mkdtemp, readFile, rm} from 'node:fs/promises'
+import {tmpdir} from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+import semver from 'semver'
+
+import {commandExists} from '../utils/command.mjs'
+
+export const RELEASE_TYPES = [
+  'major',
+  'minor',
+  'patch',
+  'premajor',
+  'preminor',
+  'prepatch',
+  'prerelease'
+]
+const STABLE_RELEASE_TYPES = ['major', 'minor', 'patch']
+
+function sanitizeSuggestedReleaseType(message, allowedTypes = RELEASE_TYPES) {
+  if (typeof message !== 'string') {
+    return null
+  }
+
+  const normalized = message
+    .trim()
+    .toLowerCase()
+    .replace(/^release type:\s*/i, '')
+    .split(/\s+/)[0]
+    ?.replace(/[^a-z]/g, '')
+
+  if (!normalized || !allowedTypes.includes(normalized)) {
+    return null
+  }
+
+  return normalized
+}
+
+function inferReleaseTypeHeuristically({
+  currentVersion = '0.0.0',
+  commitLog = '',
+  diffStat = ''
+} = {}) {
+  const combined = `${commitLog}\n${diffStat}`
+  const hasBreakingChange = /breaking change|breaking changes|^[a-z]+(?:\(.+\))?!:/im.test(combined)
+  const hasFeatureChange = /\bfeat(?:\(.+\))?:/im.test(commitLog) || /\bfeature\b/i.test(combined)
+  const hasPrereleaseVersion = Array.isArray(semver.parse(currentVersion)?.prerelease)
+    && semver.parse(currentVersion)?.prerelease?.length > 0
+
+  if (hasPrereleaseVersion) {
+    if (hasBreakingChange) {
+      return 'premajor'
+    }
+
+    if (hasFeatureChange) {
+      return 'preminor'
+    }
+
+    return 'prerelease'
+  }
+
+  if (hasBreakingChange) {
+    return 'major'
+  }
+
+  if (hasFeatureChange) {
+    return 'minor'
+  }
+
+  return 'patch'
+}
+
+function resolveSuggestedReleaseTypeOptions(currentVersion = '0.0.0') {
+  const parsedVersion = semver.parse(currentVersion)
+
+  if (Array.isArray(parsedVersion?.prerelease) && parsedVersion.prerelease.length > 0) {
+    return RELEASE_TYPES
+  }
+
+  return STABLE_RELEASE_TYPES
+}
+
+function buildChoiceOrder(suggestedReleaseType) {
+  return [
+    suggestedReleaseType,
+    ...RELEASE_TYPES.filter((type) => type !== suggestedReleaseType)
+  ]
+}
+
+async function readLatestReleaseTag(rootDir, {runCommand} = {}) {
+  try {
+    const {stdout} = await runCommand('git', ['describe', '--tags', '--abbrev=0'], {
+      capture: true,
+      cwd: rootDir
+    })
+
+    return stdout.trim() || null
+  } catch {
+    return null
+  }
+}
+
+async function readCommitLog(rootDir, {runCommand, latestTag} = {}) {
+  const args = latestTag
+    ? ['log', '--format=%h %s', `${latestTag}..HEAD`]
+    : ['log', '--format=%h %s', '-20']
+
+  try {
+    const {stdout} = await runCommand('git', args, {
+      capture: true,
+      cwd: rootDir
+    })
+
+    return stdout.trim()
+  } catch {
+    return ''
+  }
+}
+
+async function readDiffStat(rootDir, {runCommand, latestTag} = {}) {
+  const args = latestTag
+    ? ['diff', '--stat', `${latestTag}..HEAD`, '--']
+    : ['diff', '--stat', 'HEAD~20..HEAD', '--']
+
+  try {
+    const {stdout} = await runCommand('git', args, {
+      capture: true,
+      cwd: rootDir
+    })
+
+    return stdout.trim()
+  } catch {
+    return ''
+  }
+}
+
+async function buildReleaseSuggestionContext(rootDir, {
+  runCommand,
+  currentVersion,
+  packageName
+} = {}) {
+  const latestTag = await readLatestReleaseTag(rootDir, {runCommand})
+  const commitLog = await readCommitLog(rootDir, {runCommand, latestTag})
+  const diffStat = await readDiffStat(rootDir, {runCommand, latestTag})
+
+  return {
+    currentVersion,
+    packageName,
+    latestTag,
+    commitLog,
+    diffStat
+  }
+}
+
+async function suggestReleaseType(rootDir = process.cwd(), {
+  runCommand,
+  currentVersion,
+  packageName,
+  commandExistsImpl = commandExists,
+  logStep,
+  logWarning
+} = {}) {
+  const context = await buildReleaseSuggestionContext(rootDir, {
+    runCommand,
+    currentVersion,
+    packageName
+  })
+  const allowedSuggestedReleaseTypes = resolveSuggestedReleaseTypeOptions(currentVersion)
+  const heuristicReleaseType = inferReleaseTypeHeuristically(context)
+
+  if (!commandExistsImpl('codex')) {
+    return {
+      ...context,
+      releaseType: heuristicReleaseType,
+      source: 'heuristic'
+    }
+  }
+
+  let tempDir = null
+
+  try {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'zephyr-release-type-'))
+    const outputPath = path.join(tempDir, 'codex-last-message.txt')
+
+    logStep?.('Evaluating the recommended version bump with Codex...')
+
+    await runCommand('codex', [
+      'exec',
+      '--ephemeral',
+      '--model',
+      'gpt-5.4-mini',
+      '--sandbox',
+      'read-only',
+      '--skip-git-repo-check',
+      '--output-last-message',
+      outputPath,
+      [
+        'Choose exactly one semver release type for the next release.',
+        `Reply with exactly one of: ${allowedSuggestedReleaseTypes.join(', ')}.`,
+        'Base the choice on the actual code and workflow changes since the last release tag.',
+        'Prefer stable release types unless the current version already has a prerelease identifier.',
+        `Package: ${packageName || 'unknown package'}`,
+        `Current version: ${currentVersion || 'unknown'}`,
+        `Latest release tag: ${context.latestTag || 'none found'}`,
+        'Commits since the last release:',
+        context.commitLog || '- no commits found',
+        'Diff summary since the last release:',
+        context.diffStat || '- no diff summary available'
+      ].join('\n\n')
+    ], {
+      capture: true,
+      cwd: rootDir
+    })
+
+    const rawSuggestion = await readFile(outputPath, 'utf8')
+    const releaseType = sanitizeSuggestedReleaseType(rawSuggestion, allowedSuggestedReleaseTypes)
+
+    if (!releaseType) {
+      return {
+        ...context,
+        releaseType: heuristicReleaseType,
+        source: 'heuristic'
+      }
+    }
+
+    return {
+      ...context,
+      releaseType,
+      source: 'codex'
+    }
+  } catch (error) {
+    logWarning?.(`Codex could not suggest a release type: ${error.message}`)
+
+    return {
+      ...context,
+      releaseType: heuristicReleaseType,
+      source: 'heuristic'
+    }
+  } finally {
+    if (tempDir) {
+      await rm(tempDir, {recursive: true, force: true}).catch(() => {})
+    }
+  }
+}
+
+export async function resolveReleaseType({
+  releaseType = null,
+  currentVersion = '0.0.0',
+  packageName = '',
+  rootDir = process.cwd(),
+  interactive = true,
+  runPrompt,
+  runCommand,
+  logStep,
+  logWarning
+} = {}) {
+  if (releaseType) {
+    return releaseType
+  }
+
+  const suggested = await suggestReleaseType(rootDir, {
+    runCommand,
+    currentVersion,
+    packageName,
+    logStep,
+    logWarning
+  })
+  const rangeLabel = suggested.latestTag
+    ? `based on changes since ${suggested.latestTag}`
+    : 'based on recent changes'
+
+  if (!interactive || typeof runPrompt !== 'function') {
+    logStep?.(`No release type specified. Using suggested ${suggested.releaseType} bump ${rangeLabel}.`)
+    return suggested.releaseType
+  }
+
+  const {selectedReleaseType} = await runPrompt([
+    {
+      type: 'list',
+      name: 'selectedReleaseType',
+      message:
+        `Recommended release bump for ${packageName || 'this package'}@${currentVersion} ` +
+        `${rangeLabel}. Choose the version bump to use:`,
+      choices: buildChoiceOrder(suggested.releaseType).map((type) => ({
+        name: type === suggested.releaseType ? `${type} (recommended)` : type,
+        value: type
+      })),
+      default: suggested.releaseType
+    }
+  ])
+
+  return selectedReleaseType
+}

package/src/release/shared.mjs

@@ -16,16 +16,9 @@ import {
   parseWorkingTreeStatus,
   suggestReleaseCommitMessage
 } from './commit-message.mjs'
+import {RELEASE_TYPES as SUPPORTED_RELEASE_TYPES} from './release-type.mjs'
 
-const RELEASE_TYPES = new Set([
-  'major',
-  'minor',
-  'patch',
-  'premajor',
-  'preminor',
-  'prepatch',
-  'prerelease'
-])
+const RELEASE_TYPES = new Set(SUPPORTED_RELEASE_TYPES)
 const DIRTY_WORKING_TREE_MESSAGE = 'Working tree has uncommitted changes. Commit or stash them before releasing.'
 const DIRTY_WORKING_TREE_CANCELLED_MESSAGE = 'Release cancelled: pending changes were not committed.'
 
@@ -58,9 +51,9 @@ export function parseReleaseArgs({
 
   const positionals = filteredArgs.filter((arg) => !arg.startsWith('--'))
   const presentFlags = new Set(filteredArgs.filter((arg) => arg.startsWith('--')))
-  const releaseType = positionals[0] ?? 'patch'
+  const releaseType = positionals[0] ?? null
 
-  if (!RELEASE_TYPES.has(releaseType)) {
+  if (releaseType && !RELEASE_TYPES.has(releaseType)) {
     throw new Error(
       `Invalid release type "${releaseType}". Use one of: ${Array.from(RELEASE_TYPES).join(', ')}.`
     )

package/src/release-node.mjs

@@ -17,7 +17,7 @@ function hasExplicitReleaseOptions(options = {}) {
 export async function releaseNode(options = {}) {
     const parsed = hasExplicitReleaseOptions(options)
         ? {
-            releaseType: options.releaseType ?? 'patch',
+            releaseType: 'releaseType' in options ? (options.releaseType ?? null) : null,
             skipGitHooks: options.skipGitHooks === true,
             skipTests: options.skipTests === true,
             skipLint: options.skipLint === true,

package/src/release-packagist.mjs

@@ -15,7 +15,7 @@ function hasExplicitReleaseOptions(options = {}) {
 export async function releasePackagist(options = {}) {
     const parsed = hasExplicitReleaseOptions(options)
         ? {
-            releaseType: options.releaseType ?? 'patch',
+            releaseType: 'releaseType' in options ? (options.releaseType ?? null) : null,
             skipGitHooks: options.skipGitHooks === true,
             skipTests: options.skipTests === true,
             skipLint: options.skipLint === true