@wyxos/zephyr 0.6.0 → 0.7.4

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

@@ -3,6 +3,7 @@ import {readFile} from 'node:fs/promises'
 import fs from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
+import semver from 'semver'
 
 import {writeStderr} from '../../utils/output.mjs'
 import {
@@ -20,6 +21,44 @@ async function readPackage(rootDir = process.cwd()) {
     return JSON.parse(raw)
 }
 
+function ensureValidPackageVersion(pkg) {
+    const version = pkg?.version
+
+    if (!version) {
+        throw new Error('package.json does not have a version field. Add a valid semver version before using --skip-versioning.')
+    }
+
+    if (!semver.valid(version)) {
+        throw new Error(`Invalid current version "${version}" in package.json. Must be a valid semver.`)
+    }
+
+    return version
+}
+
+async function ensureReleaseTagMissing(version, rootDir = process.cwd(), {
+    runCommand = runReleaseCommand
+} = {}) {
+    const tagName = `v${version}`
+    const {stdout} = await runCommand('git', ['tag', '-l', tagName], {capture: true, cwd: rootDir})
+
+    if (stdout.trim() === tagName) {
+        throw new Error(
+            `Release tag ${tagName} already exists. Remove the existing tag or update package.json before using --skip-versioning.`
+        )
+    }
+
+    return tagName
+}
+
+async function createReleaseTag(version, rootDir = process.cwd(), {
+    logStep,
+    runCommand = runReleaseCommand
+} = {}) {
+    const tagName = `v${version}`
+    logStep?.(`Creating release tag ${tagName}...`)
+    await runCommand('git', ['tag', '-a', tagName, '-m', tagName], {capture: true, cwd: rootDir})
+}
+
 function hasScript(pkg, scriptName) {
     return pkg?.scripts?.[scriptName] !== undefined
 }
@@ -354,6 +393,7 @@ export async function releaseNodePackage({
                                              skipGitHooks = false,
                                              skipTests = false,
                                              skipLint = false,
+                                             skipVersioning = false,
                                              skipBuild = false,
                                              skipDeploy = false,
                                              rootDir = process.cwd(),
@@ -373,6 +413,7 @@ export async function releaseNodePackage({
 
     logStep?.('Reading package metadata...')
     const pkg = await readPackage(rootDir)
+    const currentVersion = skipVersioning ? ensureValidPackageVersion(pkg) : null
 
     logStep?.('Validating dependencies...')
     await validateReleaseDependencies(rootDir, {
@@ -393,24 +434,39 @@ 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
-    })
+
+    if (skipVersioning) {
+        await ensureReleaseTagMissing(currentVersion, rootDir, {runCommand})
+        logWarning?.(
+            `Skipping package.json version update because --skip-versioning flag was provided. Releasing current version ${currentVersion}.`
+        )
+    }
+
+    const resolvedReleaseType = skipVersioning
+        ? null
+        : 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(resolvedReleaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
+    const updatedPkg = skipVersioning
+        ? {...pkg, version: currentVersion}
+        : await bumpVersion(resolvedReleaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
     await runBuild(skipBuild, updatedPkg, rootDir, {logStep, logSuccess, logWarning, runCommand})
+    if (skipVersioning) {
+        await createReleaseTag(updatedPkg.version, rootDir, {logStep, 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

@@ -20,6 +20,30 @@ async function readComposer(rootDir = process.cwd()) {
     return JSON.parse(raw)
 }
 
+async function ensureReleaseTagMissing(version, rootDir = process.cwd(), {
+    runCommand = runReleaseCommand
+} = {}) {
+    const tagName = `v${version}`
+    const {stdout} = await runCommand('git', ['tag', '-l', tagName], {capture: true, cwd: rootDir})
+
+    if (stdout.trim() === tagName) {
+        throw new Error(
+            `Release tag ${tagName} already exists. Remove the existing tag or update composer.json before using --skip-versioning.`
+        )
+    }
+
+    return tagName
+}
+
+async function createReleaseTag(version, rootDir = process.cwd(), {
+    logStep,
+    runCommand = runReleaseCommand
+} = {}) {
+    const tagName = `v${version}`
+    logStep?.(`Creating git tag ${tagName}...`)
+    await runCommand('git', ['tag', tagName], {cwd: rootDir})
+}
+
 async function writeComposer(rootDir, composer, composerPath = null) {
     const pathToUse = composerPath || join(rootDir, 'composer.json')
     const content = JSON.stringify(composer, null, 2) + '\n'
@@ -218,6 +242,7 @@ export async function releasePackagistPackage({
                                                   skipGitHooks = false,
                                                   skipTests = false,
                                                   skipLint = false,
+                                                  skipVersioning = false,
                                                   rootDir = process.cwd(),
                                                   logStep,
                                                   logSuccess,
@@ -241,6 +266,10 @@ export async function releasePackagistPackage({
         throw new Error('composer.json does not have a version field. Add "version": "0.0.0" to composer.json.')
     }
 
+    if (skipVersioning && !semver.valid(composer.version)) {
+        throw new Error(`Invalid current version "${composer.version}" in composer.json. Must be a valid semver.`)
+    }
+
     logStep?.('Validating dependencies...')
     await validateReleaseDependencies(rootDir, {
         prompt: runPrompt,
@@ -260,22 +289,37 @@ 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
-    })
+
+    if (skipVersioning) {
+        await ensureReleaseTagMissing(composer.version, rootDir, {runCommand})
+        logWarning?.(
+            `Skipping composer.json version update because --skip-versioning flag was provided. Releasing current version ${composer.version}.`
+        )
+    }
+
+    const resolvedReleaseType = skipVersioning
+        ? null
+        : 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(resolvedReleaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
+    const updatedComposer = skipVersioning
+        ? {...composer}
+        : await bumpVersion(resolvedReleaseType, rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
+    if (skipVersioning) {
+        await createReleaseTag(updatedComposer.version, rootDir, {logStep, runCommand})
+    }
     await pushChanges(rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
 
     logSuccess?.(`Release workflow completed for ${composer.name}@${updatedComposer.version}.`)

package/src/cli/options.mjs

@@ -5,6 +5,11 @@ import {Command} from 'commander'
 import {InvalidCliOptionsError} from '../runtime/errors.mjs'
 
 const WORKFLOW_TYPES = new Set(['node', 'vue', 'packagist'])
+
+function hasFlag(args = [], flag) {
+    return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`))
+}
+
 function normalizeMaintenanceMode(value) {
     if (value == null) {
         return null
@@ -35,6 +40,8 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         .option('--resume-pending', 'Resume a saved pending deployment snapshot without prompting.')
         .option('--discard-pending', 'Discard a saved pending deployment snapshot without prompting.')
         .option('--maintenance <mode>', 'Laravel maintenance mode policy for app deployments (on|off).')
+        .option('--auto-commit', 'Automatically commit dirty deploy changes with a Codex-generated message.')
+        .option('--skip-versioning', 'Skip updating package/composer version files before continuing.')
         .option('--skip-git-hooks', 'Bypass local git hooks for any commits and pushes Zephyr performs.')
         .option('--skip-checks', 'Skip Zephyr local lint and test execution.')
         .option('--skip-tests', 'Skip Zephyr local test execution in package release and app deployment workflows.')
@@ -54,6 +61,7 @@ export function parseCliOptions(args = process.argv.slice(2)) {
 
     const options = program.opts()
     const workflowType = options.type ?? null
+    const explicitSkipChecks = hasFlag(args, '--skip-checks')
 
     if (workflowType && !WORKFLOW_TYPES.has(workflowType)) {
         throw new InvalidCliOptionsError('Invalid value for --type. Use one of: node, vue, packagist.')
@@ -68,12 +76,21 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         resumePending: Boolean(options.resumePending),
         discardPending: Boolean(options.discardPending),
         maintenanceMode: normalizeMaintenanceMode(options.maintenance),
+        autoCommit: Boolean(options.autoCommit),
+        skipVersioning: Boolean(options.skipVersioning),
         skipGitHooks: Boolean(options.skipGitHooks),
         skipChecks: Boolean(options.skipChecks),
         skipTests: Boolean(options.skipTests || options.skipChecks),
         skipLint: Boolean(options.skipLint || options.skipChecks),
         skipBuild: Boolean(options.skipBuild),
-        skipDeploy: Boolean(options.skipDeploy)
+        skipDeploy: Boolean(options.skipDeploy),
+        explicitMaintenanceMode: hasFlag(args, '--maintenance'),
+        explicitAutoCommit: hasFlag(args, '--auto-commit'),
+        explicitSkipVersioning: hasFlag(args, '--skip-versioning'),
+        explicitSkipGitHooks: hasFlag(args, '--skip-git-hooks'),
+        explicitSkipChecks,
+        explicitSkipTests: hasFlag(args, '--skip-tests') || explicitSkipChecks,
+        explicitSkipLint: hasFlag(args, '--skip-lint') || explicitSkipChecks
     }
 }
 
@@ -86,6 +103,8 @@ export function validateCliOptions(options = {}) {
         resumePending = false,
         discardPending = false,
         maintenanceMode = null,
+        autoCommit = false,
+        skipVersioning = false,
         skipBuild = false,
         skipDeploy = false
     } = options
@@ -112,6 +131,10 @@ export function validateCliOptions(options = {}) {
         if (maintenanceMode !== null) {
             throw new InvalidCliOptionsError('--maintenance is only valid for app deployments.')
         }
+
+        if (autoCommit) {
+            throw new InvalidCliOptionsError('--auto-commit is only valid for app deployments.')
+        }
     } else {
         if (skipBuild || skipDeploy) {
             throw new InvalidCliOptionsError('--skip-build and --skip-deploy are only valid for node/vue release workflows.')
@@ -121,4 +144,8 @@ export function validateCliOptions(options = {}) {
             throw new InvalidCliOptionsError('--non-interactive app deployments require --preset <name>.')
         }
     }
+
+    if (skipVersioning && options.versionArg) {
+        throw new InvalidCliOptionsError('--skip-versioning cannot be used together with an explicit version or bump argument.')
+    }
 }

package/src/config/preset-options.mjs

@@ -0,0 +1,89 @@
+export const DEFAULT_PRESET_OPTIONS = Object.freeze({
+  maintenanceMode: null,
+  skipGitHooks: false,
+  skipTests: false,
+  skipLint: false,
+  skipVersioning: false,
+  autoCommit: false
+})
+
+function normalizeBoolean(value, fallback = false) {
+  return typeof value === 'boolean' ? value : fallback
+}
+
+function normalizeMaintenanceMode(value) {
+  return typeof value === 'boolean' ? value : null
+}
+
+export function normalizePresetOptions(options = {}) {
+  return {
+    maintenanceMode: normalizeMaintenanceMode(options?.maintenanceMode),
+    skipGitHooks: normalizeBoolean(options?.skipGitHooks),
+    skipTests: normalizeBoolean(options?.skipTests),
+    skipLint: normalizeBoolean(options?.skipLint),
+    skipVersioning: normalizeBoolean(options?.skipVersioning),
+    autoCommit: normalizeBoolean(options?.autoCommit)
+  }
+}
+
+export function mergeDeployOptions(executionMode = {}, presetOptions = {}) {
+  const normalizedPresetOptions = normalizePresetOptions(presetOptions)
+
+  return {
+    maintenanceMode: executionMode.explicitMaintenanceMode === true
+      ? executionMode.maintenanceMode
+      : normalizedPresetOptions.maintenanceMode,
+    skipGitHooks: executionMode.explicitSkipGitHooks === true
+      ? executionMode.skipGitHooks === true
+      : normalizedPresetOptions.skipGitHooks,
+    skipTests: executionMode.explicitSkipTests === true
+      ? executionMode.skipTests === true
+      : normalizedPresetOptions.skipTests,
+    skipLint: executionMode.explicitSkipLint === true
+      ? executionMode.skipLint === true
+      : normalizedPresetOptions.skipLint,
+    skipVersioning: executionMode.explicitSkipVersioning === true
+      ? executionMode.skipVersioning === true
+      : normalizedPresetOptions.skipVersioning,
+    autoCommit: executionMode.explicitAutoCommit === true
+      ? executionMode.autoCommit === true
+      : normalizedPresetOptions.autoCommit
+  }
+}
+
+export function buildPresetOptionsFromExecutionMode(executionMode = {}, existingOptions = {}) {
+  const normalizedOptions = normalizePresetOptions(existingOptions)
+
+  if (executionMode.explicitMaintenanceMode === true) {
+    normalizedOptions.maintenanceMode = executionMode.maintenanceMode
+  }
+
+  if (executionMode.explicitSkipGitHooks === true) {
+    normalizedOptions.skipGitHooks = executionMode.skipGitHooks === true
+  }
+
+  if (executionMode.explicitSkipTests === true) {
+    normalizedOptions.skipTests = executionMode.skipTests === true
+  }
+
+  if (executionMode.explicitSkipLint === true) {
+    normalizedOptions.skipLint = executionMode.skipLint === true
+  }
+
+  if (executionMode.explicitSkipVersioning === true) {
+    normalizedOptions.skipVersioning = executionMode.skipVersioning === true
+  }
+
+  if (executionMode.explicitAutoCommit === true) {
+    normalizedOptions.autoCommit = executionMode.autoCommit === true
+  }
+
+  return normalizedOptions
+}
+
+export function presetOptionsEqual(left = {}, right = {}) {
+  const normalizedLeft = normalizePresetOptions(left)
+  const normalizedRight = normalizePresetOptions(right)
+
+  return JSON.stringify(normalizedLeft) === JSON.stringify(normalizedRight)
+}

package/src/config/project.mjs

@@ -1,6 +1,10 @@
 import fs from 'node:fs/promises'
 
 import {ZephyrError} from '../runtime/errors.mjs'
+import {
+  normalizePresetOptions,
+  presetOptionsEqual
+} from './preset-options.mjs'
 import { ensureDirectory, getProjectConfigDir, getProjectConfigPath } from '../utils/paths.mjs'
 import { generateId } from '../utils/id.mjs'
 
@@ -44,27 +48,58 @@ export function migratePresets(presets, apps) {
     return { presets: [], needsMigration: false }
   }
 
-  const keyToAppId = new Map()
+  const appLookup = new Map()
   apps.forEach((app) => {
     if (app.id && app.serverName && app.projectPath) {
       const key = `${app.serverName}:${app.projectPath}`
-      keyToAppId.set(key, app.id)
+      appLookup.set(key, app)
     }
   })
 
   let needsMigration = false
-  const migrated = presets.map((preset) => {
-    const updated = { ...preset }
+  const migrated = presets.flatMap((preset) => {
+    if (!preset || typeof preset !== 'object') {
+      needsMigration = true
+      return []
+    }
 
-    if (preset.key && !preset.appId) {
-      const appId = keyToAppId.get(preset.key)
-      if (appId) {
-        needsMigration = true
-        updated.appId = appId
+    const updated = {
+      name: typeof preset.name === 'string' ? preset.name : '',
+      appId: typeof preset.appId === 'string' ? preset.appId : null,
+      branch: typeof preset.branch === 'string' ? preset.branch : null,
+      options: normalizePresetOptions(preset.options)
+    }
+
+    if (!presetOptionsEqual(updated.options, preset.options)) {
+      needsMigration = true
+    }
+
+    if (preset.key) {
+      needsMigration = true
+      const [serverName = null, projectPath = null, legacyBranch = null] = String(preset.key).split(':')
+      const app = serverName && projectPath
+        ? appLookup.get(`${serverName}:${projectPath}`)
+        : null
+
+      if (app?.id) {
+        updated.appId = app.id
+      }
+
+      if (!updated.branch && legacyBranch) {
+        updated.branch = legacyBranch
       }
     }
 
-    return updated
+    if (!updated.name) {
+      needsMigration = true
+      return []
+    }
+
+    if (!preset.appId || preset.key || preset.branch !== updated.branch) {
+      needsMigration = true
+    }
+
+    return [updated]
   })
 
   return { presets: migrated, needsMigration }

package/src/deploy/local-repo.mjs

@@ -177,6 +177,7 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
   logProcessing,
   logSuccess,
   logWarning,
+  autoCommit = false,
   skipGitHooks = false,
   suggestCommitMessage = suggestCommitMessageImpl
 } = {}) {
@@ -186,7 +187,7 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
     return
   }
 
-  if (typeof runPrompt !== 'function') {
+  if (!autoCommit && typeof runPrompt !== 'function') {
     throw new Error(DIRTY_DEPLOYMENT_MESSAGE)
   }
 
@@ -213,24 +214,34 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
     logWarning,
     statusEntries
   })
-  const { commitMessage } = await runPrompt([
-    {
-      type: 'input',
-      name: 'commitMessage',
-      message:
-        'Pending changes detected before deployment:\n\n' +
-        `${formatWorkingTreePreview(statusEntries)}\n\n` +
-        'Enter a commit message to stage and commit all current changes before continuing.\n' +
-        'Leave blank to cancel.',
-      default: suggestedCommitMessage ?? ''
+  let message = suggestedCommitMessage?.trim() ?? ''
+
+  if (autoCommit) {
+    if (!message) {
+      throw new Error('Deployment auto-commit failed because Codex could not determine a usable commit message.')
     }
-  ])
 
-  if (!commitMessage || commitMessage.trim().length === 0) {
-    throw new Error(DIRTY_DEPLOYMENT_CANCELLED_MESSAGE)
-  }
+    logProcessing?.(`Auto-commit enabled. Using Codex-generated commit message "${message}".`)
+  } else {
+    const { commitMessage } = await runPrompt([
+      {
+        type: 'input',
+        name: 'commitMessage',
+        message:
+          'Pending changes detected before deployment:\n\n' +
+          `${formatWorkingTreePreview(statusEntries)}\n\n` +
+          'Enter a commit message to stage and commit all current changes before continuing.\n' +
+          'Leave blank to cancel.',
+        default: message
+      }
+    ])
 
-  const message = commitMessage.trim()
+    if (!commitMessage || commitMessage.trim().length === 0) {
+      throw new Error(DIRTY_DEPLOYMENT_CANCELLED_MESSAGE)
+    }
+
+    message = commitMessage.trim()
+  }
 
   logProcessing?.('Staging all pending changes before deployment...')
   await runCommand('git', ['add', '-A'], { cwd: rootDir })
@@ -357,6 +368,7 @@ export async function ensureLocalRepositoryState(targetBranch, rootDir = process
   logProcessing,
   logSuccess,
   logWarning,
+  autoCommit = false,
   skipGitHooks = false,
   suggestCommitMessage: suggestCommitMessageFn = suggestCommitMessageImpl,
   getCurrentBranch: getCurrentBranchFn = getCurrentBranch,
@@ -436,6 +448,7 @@ export async function ensureLocalRepositoryState(targetBranch, rootDir = process
     logProcessing,
     logSuccess,
     logWarning,
+    autoCommit,
     skipGitHooks,
     suggestCommitMessage: suggestCommitMessageFn
   })

package/src/deploy/preflight.mjs

@@ -25,17 +25,30 @@ export async function hasPrePushHook(rootDir) {
   return false
 }
 
+async function readPackageJson(rootDir) {
+  const packageJsonPath = path.join(rootDir, 'package.json')
+  const raw = await fs.readFile(packageJsonPath, 'utf8')
+  return JSON.parse(raw)
+}
+
 export async function hasLintScript(rootDir) {
   try {
-    const packageJsonPath = path.join(rootDir, 'package.json')
-    const raw = await fs.readFile(packageJsonPath, 'utf8')
-    const packageJson = JSON.parse(raw)
+    const packageJson = await readPackageJson(rootDir)
     return packageJson.scripts && typeof packageJson.scripts.lint === 'string'
   } catch {
     return false
   }
 }
 
+export async function hasBuildScript(rootDir) {
+  try {
+    const packageJson = await readPackageJson(rootDir)
+    return packageJson.scripts && typeof packageJson.scripts.build === 'string'
+  } catch {
+    return false
+  }
+}
+
 export async function hasLaravelPint(rootDir) {
   try {
     const pintPath = path.join(rootDir, 'vendor', 'bin', 'pint')
@@ -91,6 +104,28 @@ export async function resolveSupportedLintCommand(rootDir, {commandExists} = {})
   throw error
 }
 
+export async function resolveSupportedBuildCommand(rootDir, {commandExists} = {}) {
+  const hasNpmBuild = await hasBuildScript(rootDir)
+
+  if (!hasNpmBuild) {
+    return null
+  }
+
+  if (commandExists && !commandExists('npm')) {
+    throw new Error(
+      'Release cannot run because `npm run build` is configured but npm is not available in PATH.\n' +
+      'Install npm or fix your PATH before deploying.'
+    )
+  }
+
+  return {
+    type: 'npm',
+    command: 'npm',
+    args: ['run', 'build'],
+    label: 'npm build'
+  }
+}
+
 export async function runLinting(rootDir, {
   runCommand,
   logProcessing,
@@ -117,6 +152,25 @@ export async function runLinting(rootDir, {
   return false
 }
 
+export async function runBuild(rootDir, {
+  runCommand,
+  logProcessing,
+  logSuccess,
+  commandExists,
+  buildCommand = null
+} = {}) {
+  const selectedBuildCommand = buildCommand ?? await resolveSupportedBuildCommand(rootDir, {commandExists})
+
+  if (selectedBuildCommand === null) {
+    return false
+  }
+
+  logProcessing?.('Running local frontend build...')
+  await runCommand(selectedBuildCommand.command, selectedBuildCommand.args, {cwd: rootDir})
+  logSuccess?.('Local frontend build completed.')
+  return true
+}
+
 export function hasStagedChanges(statusOutput) {
   if (!statusOutput || statusOutput.length === 0) {
     return false