@wyxos/zephyr 0.4.8 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.4.8",
+  "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/main.mjs

@@ -17,6 +17,7 @@ import {selectDeploymentTarget} from './application/configuration/select-deploym
 import {resolvePendingSnapshot} from './application/deploy/resolve-pending-snapshot.mjs'
 import {runDeployment} from './application/deploy/run-deployment.mjs'
 import {SKIP_GIT_HOOKS_WARNING} from './utils/git-hooks.mjs'
+import {notifyWorkflowResult} from './utils/notifications.mjs'
 
 const RELEASE_SCRIPT_NAME = 'release'
 const RELEASE_SCRIPT_COMMAND = 'npx @wyxos/zephyr@latest'
@@ -99,6 +100,7 @@ async function runRemoteTasks(config, options = {}) {
 
 async function main(optionsOrWorkflowType = null, versionArg = null) {
     const options = normalizeMainOptions(optionsOrWorkflowType, versionArg)
+    const rootDir = process.cwd()
 
     const executionMode = {
         interactive: !options.nonInteractive,
@@ -171,6 +173,14 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                     workflow: currentExecutionMode.workflow
                 }
             })
+            if (!currentExecutionMode.json) {
+                await notifyWorkflowResult({
+                    status: 'success',
+                    workflow: currentExecutionMode.workflow,
+                    presetName: currentExecutionMode.presetName,
+                    rootDir
+                })
+            }
             return
         }
 
@@ -189,11 +199,17 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                     workflow: currentExecutionMode.workflow
                 }
             })
+            if (!currentExecutionMode.json) {
+                await notifyWorkflowResult({
+                    status: 'success',
+                    workflow: currentExecutionMode.workflow,
+                    presetName: currentExecutionMode.presetName,
+                    rootDir
+                })
+            }
             return
         }
 
-        const rootDir = process.cwd()
-
         await bootstrap.ensureGitignoreEntry(rootDir, {
             projectConfigDir: PROJECT_CONFIG_DIR,
             runCommand,
@@ -256,6 +272,14 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                 workflow: currentExecutionMode.workflow
             }
         })
+        if (!currentExecutionMode.json) {
+            await notifyWorkflowResult({
+                status: 'success',
+                workflow: currentExecutionMode.workflow,
+                presetName: currentExecutionMode.presetName,
+                rootDir
+            })
+        }
     } catch (error) {
         const errorCode = getErrorCode(error)
         emitEvent?.('run_failed', {
@@ -272,6 +296,13 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             if (errorCode === 'ZEPHYR_FAILURE' && error.stack) {
                 writeStderrLine(error.stack)
             }
+            await notifyWorkflowResult({
+                status: 'failure',
+                workflow: currentExecutionMode.workflow,
+                presetName: currentExecutionMode.presetName,
+                rootDir,
+                message: error.message
+            })
         }
 
         throw error

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

package/src/utils/notifications.mjs

@@ -0,0 +1,101 @@
+import path from 'node:path'
+import process from 'node:process'
+
+import {commandExists, runCommand as runCommandBase} from './command.mjs'
+
+const MAX_NOTIFICATION_MESSAGE_LENGTH = 180
+
+function escapeAppleScriptString(value = '') {
+  return String(value ?? '')
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+}
+
+function humanizeWorkflow(workflow = 'deploy') {
+  if (workflow === 'release-node') {
+    return 'Node Release'
+  }
+
+  if (workflow === 'release-packagist') {
+    return 'Packagist Release'
+  }
+
+  return 'Deploy'
+}
+
+function truncateNotificationMessage(message = '') {
+  const normalized = String(message ?? '').replace(/\s+/g, ' ').trim()
+
+  if (normalized.length <= MAX_NOTIFICATION_MESSAGE_LENGTH) {
+    return normalized
+  }
+
+  return `${normalized.slice(0, MAX_NOTIFICATION_MESSAGE_LENGTH - 1).trimEnd()}…`
+}
+
+function buildNotificationPayload({
+  status = 'success',
+  workflow = 'deploy',
+  presetName = null,
+  rootDir = process.cwd(),
+  message = ''
+} = {}) {
+  const isSuccess = status === 'success'
+  const repoName = path.basename(rootDir || process.cwd()) || 'project'
+  const title = isSuccess ? '🟢 Zephyr Passed' : '🔴 Zephyr Failed'
+  const subtitleParts = [humanizeWorkflow(workflow), repoName]
+
+  if (presetName) {
+    subtitleParts.push(presetName)
+  }
+
+  return {
+    title,
+    subtitle: subtitleParts.join(' • '),
+    message: isSuccess
+      ? 'Workflow completed successfully.'
+      : truncateNotificationMessage(message || 'Workflow failed.'),
+    soundName: isSuccess ? 'Glass' : 'Basso'
+  }
+}
+
+export async function notifyWorkflowResult({
+  status = 'success',
+  workflow = 'deploy',
+  presetName = null,
+  rootDir = process.cwd(),
+  message = ''
+} = {}, {
+  processRef = process,
+  commandExistsImpl = commandExists,
+  runCommand = runCommandBase
+} = {}) {
+  if (processRef.platform !== 'darwin' || !commandExistsImpl('osascript')) {
+    return false
+  }
+
+  const payload = buildNotificationPayload({
+    status,
+    workflow,
+    presetName,
+    rootDir,
+    message
+  })
+
+  const script = [
+    `display notification "${escapeAppleScriptString(payload.message)}"`,
+    `with title "${escapeAppleScriptString(payload.title)}"`,
+    `subtitle "${escapeAppleScriptString(payload.subtitle)}"`,
+    `sound name "${escapeAppleScriptString(payload.soundName)}"`
+  ].join(' ')
+
+  try {
+    await runCommand('osascript', ['-e', script], {
+      cwd: rootDir,
+      stdio: 'ignore'
+    })
+    return true
+  } catch {
+    return false
+  }
+}