@wyxos/zephyr 0.8.4 → 0.9.1

package/README.md

@@ -40,7 +40,10 @@ Common workflows:
 # Deploy an app using the saved preset or the interactive prompts
 zephyr
 
-# Deploy an app with a local npm package version bump
+# Deploy an app with Zephyr's recommended local npm package version bump
+zephyr
+
+# Deploy an app with an explicit local npm package version bump
 zephyr minor
 
 # Deploy an app while bypassing Zephyr's built-in local checks
@@ -64,7 +67,7 @@ zephyr --non-interactive --preset wyxos-release --resume-pending --maintenance o
 # Emit NDJSON events for automation or agent tooling
 zephyr --non-interactive --json --preset wyxos-release --maintenance on
 
-# Release a Node/Vue package (defaults to a patch bump)
+# Release a Node/Vue package with Zephyr's recommended bump
 zephyr --type node
 
 # Release a Node/Vue package with an explicit bump
@@ -81,7 +84,7 @@ zephyr --type node --skip-versioning
 zephyr --type packagist --skip-versioning
 ```
 
-When `--type node` or `--type vue` is used without a bump argument, Zephyr defaults to `patch`.
+When an app deployment or a `--type node`/`--type vue` package release omits the bump argument, Zephyr recommends a version bump from changes since the last release reference, using Codex when available and deterministic heuristics as a fallback.
 
 ## Interactive and Non-Interactive Modes
 

package/package.json

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

package/src/application/deploy/bump-local-package-version.mjs

@@ -1,8 +1,11 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
+import semver from 'semver'
+
 import {commandExists} from '../../utils/command.mjs'
 import {gitCommitArgs} from '../../utils/git-hooks.mjs'
+import {resolveReleaseType} from '../../release/release-type.mjs'
 
 async function readPackageJson(rootDir) {
     const packageJsonPath = path.join(rootDir, 'package.json')
@@ -19,8 +22,109 @@ async function isGitIgnored(rootDir, filePath, {runCommand} = {}) {
     }
 }
 
+function parseVersionBumpCommit(line) {
+    const [hash, shortHash, subject] = line.split('\0')
+    const match = /^chore: bump version to (\d+\.\d+\.\d+(?:[-+][^\s]+)?)$/i.exec(subject ?? '')
+
+    if (!match) {
+        return null
+    }
+
+    return {hash, shortHash, version: match[1]}
+}
+
+async function readVersionBumpCommits(rootDir, {runCommand} = {}) {
+    if (typeof runCommand !== 'function') {
+        return []
+    }
+
+    try {
+        const {stdout = ''} = await runCommand('git', ['log', '--format=%H%x00%h%x00%s', '-1000'], {
+            capture: true,
+            cwd: rootDir
+        })
+
+        return stdout
+            .split('\n')
+            .map(parseVersionBumpCommit)
+            .filter(Boolean)
+    } catch {
+        return []
+    }
+}
+
+function selectVersionSuggestionReference(currentVersion, versionBumps) {
+    const current = semver.parse(currentVersion)
+
+    if (!current) {
+        return versionBumps[0] ?? null
+    }
+
+    const currentMinorBoundary = versionBumps.find(({version}) => {
+        const parsed = semver.parse(version)
+
+        return parsed
+            && parsed.major === current.major
+            && parsed.minor === current.minor
+            && parsed.patch === 0
+            && parsed.prerelease.length === 0
+    })
+
+    return currentMinorBoundary ?? versionBumps[0] ?? null
+}
+
+function formatVersionReferenceLabel(reference, currentVersion) {
+    if (!reference) {
+        return null
+    }
+
+    const current = semver.parse(currentVersion)
+    const parsed = semver.parse(reference.version)
+    const isCurrentMinorBoundary = current
+        && parsed
+        && parsed.major === current.major
+        && parsed.minor === current.minor
+        && parsed.patch === 0
+        && parsed.prerelease.length === 0
+    const prefix = isCurrentMinorBoundary ? 'current app minor baseline' : 'last app version bump'
+
+    return `${prefix} ${reference.shortHash} (${reference.version})`
+}
+
+async function resolveDeploymentVersionValue(rootDir, {
+    versionArg = null,
+    pkg,
+    interactive = false,
+    runPrompt,
+    runCommand,
+    logProcessing,
+    logWarning
+} = {}) {
+    if (versionArg && String(versionArg).trim().length > 0) {
+        return String(versionArg).trim()
+    }
+
+    const versionBumps = await readVersionBumpCommits(rootDir, {runCommand})
+    const versionReference = selectVersionSuggestionReference(pkg.version, versionBumps)
+
+    return await resolveReleaseType({
+        currentVersion: pkg.version,
+        packageName: pkg.name ?? 'this app',
+        rootDir,
+        interactive,
+        runPrompt,
+        runCommand,
+        logStep: logProcessing,
+        logWarning,
+        latestTag: versionReference?.hash ?? null,
+        referenceLabel: formatVersionReferenceLabel(versionReference, pkg.version)
+    })
+}
+
 export async function bumpLocalPackageVersion(rootDir, {
     versionArg = null,
+    interactive = false,
+    runPrompt,
     skipGitHooks = false,
     runCommand,
     logProcessing,
@@ -43,9 +147,15 @@ export async function bumpLocalPackageVersion(rootDir, {
         return null
     }
 
-    const releaseValue = (versionArg && String(versionArg).trim().length > 0)
-        ? String(versionArg).trim()
-        : 'patch'
+    const releaseValue = await resolveDeploymentVersionValue(rootDir, {
+        versionArg,
+        pkg,
+        interactive,
+        runPrompt,
+        runCommand,
+        logProcessing,
+        logWarning
+    })
 
     logProcessing?.(`Bumping npm package version (${releaseValue})...`)
     await runCommand('npm', ['version', releaseValue, '--no-git-tag-version', '--force'], {cwd: rootDir})

package/src/application/deploy/prepare-local-deployment.mjs

@@ -14,6 +14,7 @@ export async function prepareLocalDeployment(config, {
     skipLint = false,
     skipVersioning = false,
     autoCommit = false,
+    interactive = true,
     runPrompt,
     runCommand,
     runCommandCapture,
@@ -66,6 +67,8 @@ export async function prepareLocalDeployment(config, {
             await bumpLocalPackageVersion(rootDir, {
                 versionArg,
                 skipGitHooks,
+                interactive,
+                runPrompt,
                 runCommand,
                 logProcessing,
                 logSuccess,

package/src/application/deploy/run-deployment.mjs

@@ -385,6 +385,7 @@ export async function runDeployment(config, options = {}) {
             skipLint: executionMode?.skipLint === true,
             skipVersioning: executionMode?.skipVersioning === true,
             autoCommit: executionMode?.autoCommit === true,
+            interactive: executionMode?.interactive !== false,
             runPrompt,
             runCommand,
             runCommandCapture: context.runCommandCapture,

package/src/release/release-type.mjs

@@ -87,7 +87,11 @@ function buildChoiceOrder(suggestedReleaseType) {
   ]
 }
 
-async function readLatestReleaseTag(rootDir, {runCommand} = {}) {
+async function readLatestReleaseTag(rootDir, {runCommand, latestTag = null} = {}) {
+  if (typeof latestTag === 'string' && latestTag.trim() !== '') {
+    return latestTag.trim()
+  }
+
   try {
     const {stdout} = await runCommand('git', ['describe', '--tags', '--abbrev=0'], {
       capture: true,
@@ -137,16 +141,19 @@ async function readDiffStat(rootDir, {runCommand, latestTag} = {}) {
 async function buildReleaseSuggestionContext(rootDir, {
   runCommand,
   currentVersion,
-  packageName
+  packageName,
+  latestTag = null,
+  referenceLabel = null
 } = {}) {
-  const latestTag = await readLatestReleaseTag(rootDir, {runCommand})
-  const commitLog = await readCommitLog(rootDir, {runCommand, latestTag})
-  const diffStat = await readDiffStat(rootDir, {runCommand, latestTag})
+  const resolvedLatestTag = await readLatestReleaseTag(rootDir, {runCommand, latestTag})
+  const commitLog = await readCommitLog(rootDir, {runCommand, latestTag: resolvedLatestTag})
+  const diffStat = await readDiffStat(rootDir, {runCommand, latestTag: resolvedLatestTag})
 
   return {
     currentVersion,
     packageName,
-    latestTag,
+    latestTag: resolvedLatestTag,
+    referenceLabel: referenceLabel ?? resolvedLatestTag,
     commitLog,
     diffStat
   }
@@ -158,12 +165,16 @@ async function suggestReleaseType(rootDir = process.cwd(), {
   packageName,
   commandExistsImpl = commandExists,
   logStep,
-  logWarning
+  logWarning,
+  latestTag = null,
+  referenceLabel = null
 } = {}) {
   const context = await buildReleaseSuggestionContext(rootDir, {
     runCommand,
     currentVersion,
-    packageName
+    packageName,
+    latestTag,
+    referenceLabel
   })
   const allowedSuggestedReleaseTypes = resolveSuggestedReleaseTypeOptions(currentVersion)
   const heuristicReleaseType = inferReleaseTypeHeuristically(context)
@@ -201,7 +212,7 @@ async function suggestReleaseType(rootDir = process.cwd(), {
         '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'}`,
+        `Latest release reference: ${context.referenceLabel || context.latestTag || 'none found'}`,
         'Commits since the last release:',
         context.commitLog || '- no commits found',
         'Diff summary since the last release:',
@@ -252,7 +263,9 @@ export async function resolveReleaseType({
   runPrompt,
   runCommand,
   logStep,
-  logWarning
+  logWarning,
+  latestTag = null,
+  referenceLabel = null
 } = {}) {
   if (releaseType) {
     return releaseType
@@ -263,10 +276,12 @@ export async function resolveReleaseType({
     currentVersion,
     packageName,
     logStep,
-    logWarning
+    logWarning,
+    latestTag,
+    referenceLabel
   })
-  const rangeLabel = suggested.latestTag
-    ? `based on changes since ${suggested.latestTag}`
+  const rangeLabel = suggested.referenceLabel || suggested.latestTag
+    ? `based on changes since ${suggested.referenceLabel || suggested.latestTag}`
     : 'based on recent changes'
 
   if (!interactive || typeof runPrompt !== 'function') {