@wyxos/zephyr 0.5.0 → 0.7.4

package/src/deploy/local-repo.mjs

@@ -2,7 +2,6 @@ import { getCurrentBranch as getCurrentBranchImpl, getUpstreamRef as getUpstream
 import {hasPrePushHook} from './preflight.mjs'
 import {gitCommitArgs, gitPushArgs} from '../utils/git-hooks.mjs'
 import {
-  buildFallbackCommitMessage,
   formatWorkingTreePreview,
   parseWorkingTreeEntries,
   suggestCommitMessage as suggestCommitMessageImpl
@@ -178,6 +177,7 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
   logProcessing,
   logSuccess,
   logWarning,
+  autoCommit = false,
   skipGitHooks = false,
   suggestCommitMessage = suggestCommitMessageImpl
 } = {}) {
@@ -187,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,36 +213,35 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
     logStep: logProcessing,
     logWarning,
     statusEntries
-  }) ?? buildFallbackCommitMessage(statusEntries)
-
-  const changeLabel = statusEntries.length === 1 ? 'change' : 'changes'
-  const {shouldCommitPendingChanges} = await runPrompt([
-    {
-      type: 'confirm',
-      name: 'shouldCommitPendingChanges',
-      message:
-        `Pending ${changeLabel} detected before deployment:\n\n` +
-        `${formatWorkingTreePreview(statusEntries)}\n\n` +
-        'Stage and commit all current changes before continuing?',
-      default: true
+  })
+  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 (!shouldCommitPendingChanges) {
-    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 { commitMessage } = await runPrompt([
-    {
-      type: 'input',
-      name: 'commitMessage',
-      message: 'Commit message for pending deployment changes',
-      default: suggestedCommitMessage,
-      validate: (value) => (value && value.trim().length > 0 ? true : 'Commit message cannot be empty.')
+    if (!commitMessage || commitMessage.trim().length === 0) {
+      throw new Error(DIRTY_DEPLOYMENT_CANCELLED_MESSAGE)
     }
-  ])
 
-  const message = commitMessage.trim()
+    message = commitMessage.trim()
+  }
 
   logProcessing?.('Staging all pending changes before deployment...')
   await runCommand('git', ['add', '-A'], { cwd: rootDir })
@@ -369,6 +368,7 @@ export async function ensureLocalRepositoryState(targetBranch, rootDir = process
   logProcessing,
   logSuccess,
   logWarning,
+  autoCommit = false,
   skipGitHooks = false,
   suggestCommitMessage: suggestCommitMessageFn = suggestCommitMessageImpl,
   getCurrentBranch: getCurrentBranchFn = getCurrentBranch,
@@ -448,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

package/src/main.mjs

@@ -11,6 +11,7 @@ import * as bootstrap from './project/bootstrap.mjs'
 import {getErrorCode, ZephyrError} from './runtime/errors.mjs'
 import {PROJECT_CONFIG_DIR} from './utils/paths.mjs'
 import {writeStderrLine} from './utils/output.mjs'
+import {mergeDeployOptions} from './config/preset-options.mjs'
 import {createAppContext} from './runtime/app-context.mjs'
 import {createConfigurationService} from './application/configuration/service.mjs'
 import {selectDeploymentTarget} from './application/configuration/select-deployment-target.mjs'
@@ -35,11 +36,21 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
             resumePending: firstArg.resumePending === true,
             discardPending: firstArg.discardPending === true,
             maintenanceMode: firstArg.maintenanceMode ?? null,
+            autoCommit: firstArg.autoCommit === true,
+            skipVersioning: firstArg.skipVersioning === true,
             skipGitHooks: firstArg.skipGitHooks === true,
-            skipTests: firstArg.skipTests === true,
-            skipLint: firstArg.skipLint === true,
+            skipChecks: firstArg.skipChecks === true,
+            skipTests: firstArg.skipTests === true || firstArg.skipChecks === true,
+            skipLint: firstArg.skipLint === true || firstArg.skipChecks === true,
             skipBuild: firstArg.skipBuild === true,
             skipDeploy: firstArg.skipDeploy === true,
+            explicitMaintenanceMode: firstArg.explicitMaintenanceMode === true || 'maintenanceMode' in firstArg,
+            explicitAutoCommit: firstArg.explicitAutoCommit === true || 'autoCommit' in firstArg,
+            explicitSkipVersioning: firstArg.explicitSkipVersioning === true || 'skipVersioning' in firstArg,
+            explicitSkipGitHooks: firstArg.explicitSkipGitHooks === true || 'skipGitHooks' in firstArg,
+            explicitSkipChecks: firstArg.explicitSkipChecks === true || 'skipChecks' in firstArg,
+            explicitSkipTests: firstArg.explicitSkipTests === true || 'skipTests' in firstArg || 'skipChecks' in firstArg,
+            explicitSkipLint: firstArg.explicitSkipLint === true || 'skipLint' in firstArg || 'skipChecks' in firstArg,
             context: firstArg.context ?? null
         }
     }
@@ -53,11 +64,21 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
         resumePending: false,
         discardPending: false,
         maintenanceMode: null,
+        autoCommit: false,
+        skipVersioning: false,
         skipGitHooks: false,
+        skipChecks: false,
         skipTests: false,
         skipLint: false,
         skipBuild: false,
         skipDeploy: false,
+        explicitMaintenanceMode: false,
+        explicitAutoCommit: false,
+        explicitSkipVersioning: false,
+        explicitSkipGitHooks: false,
+        explicitSkipChecks: false,
+        explicitSkipTests: false,
+        explicitSkipLint: false,
         context: null
     }
 }
@@ -108,9 +129,21 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
         workflow: resolveWorkflowName(options.workflowType),
         presetName: options.presetName,
         maintenanceMode: options.maintenanceMode,
+        autoCommit: options.autoCommit === true,
+        skipVersioning: options.skipVersioning === true,
         skipGitHooks: options.skipGitHooks === true,
+        skipChecks: options.skipChecks === true,
+        skipTests: options.skipTests === true,
+        skipLint: options.skipLint === true,
         resumePending: options.resumePending,
-        discardPending: options.discardPending
+        discardPending: options.discardPending,
+        explicitMaintenanceMode: options.explicitMaintenanceMode === true,
+        explicitAutoCommit: options.explicitAutoCommit === true,
+        explicitSkipVersioning: options.explicitSkipVersioning === true,
+        explicitSkipGitHooks: options.explicitSkipGitHooks === true,
+        explicitSkipChecks: options.explicitSkipChecks === true,
+        explicitSkipTests: options.explicitSkipTests === true,
+        explicitSkipLint: options.explicitSkipLint === true
     }
     const appContext = options.context ?? createAppContext({executionMode})
     const {
@@ -122,7 +155,11 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
         runCommand,
         emitEvent
     } = appContext
-    const currentExecutionMode = appContext.executionMode ?? executionMode
+    let currentExecutionMode = {
+        ...executionMode,
+        ...(appContext.executionMode ?? {})
+    }
+    appContext.executionMode = currentExecutionMode
     const configurationService = createConfigurationService(appContext)
 
     try {
@@ -137,7 +174,12 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                     nonInteractive: currentExecutionMode.interactive === false,
                     presetName: currentExecutionMode.presetName,
                     maintenanceMode: currentExecutionMode.maintenanceMode,
+                    autoCommit: currentExecutionMode.autoCommit === true,
+                    skipVersioning: currentExecutionMode.skipVersioning === true,
                     skipGitHooks: currentExecutionMode.skipGitHooks === true,
+                    skipChecks: currentExecutionMode.skipChecks === true,
+                    skipTests: currentExecutionMode.skipTests === true,
+                    skipLint: currentExecutionMode.skipLint === true,
                     resumePending: currentExecutionMode.resumePending,
                     discardPending: currentExecutionMode.discardPending
                 }
@@ -162,6 +204,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                 skipGitHooks: options.skipGitHooks,
                 skipTests: options.skipTests,
                 skipLint: options.skipLint,
+                skipVersioning: options.skipVersioning,
                 skipBuild: options.skipBuild,
                 skipDeploy: options.skipDeploy,
                 context: appContext
@@ -190,6 +233,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                 skipGitHooks: options.skipGitHooks,
                 skipTests: options.skipTests,
                 skipLint: options.skipLint,
+                skipVersioning: options.skipVersioning,
                 context: appContext
             })
             emitEvent?.('run_completed', {
@@ -241,7 +285,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             })
         }
 
-        const {deploymentConfig} = await selectDeploymentTarget(rootDir, {
+        const {deploymentConfig, presetState} = await selectDeploymentTarget(rootDir, {
             configurationService,
             runPrompt,
             logProcessing,
@@ -251,6 +295,19 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             executionMode: currentExecutionMode
         })
 
+        if (presetState) {
+            const effectiveDeployOptions = mergeDeployOptions(currentExecutionMode, presetState.options)
+            currentExecutionMode = {
+                ...currentExecutionMode,
+                presetName: presetState.name,
+                ...effectiveDeployOptions,
+                skipChecks: currentExecutionMode.skipChecks === true ||
+                    (effectiveDeployOptions.skipTests === true && effectiveDeployOptions.skipLint === true)
+            }
+            appContext.executionMode = currentExecutionMode
+            await presetState.applyExecutionMode(currentExecutionMode)
+        }
+
         const snapshotToUse = await resolvePendingSnapshot(rootDir, deploymentConfig, {
             runPrompt,
             logProcessing,
@@ -262,7 +319,8 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             rootDir,
             snapshot: snapshotToUse,
             versionArg: options.versionArg,
-            context: appContext
+            context: appContext,
+            presetState
         })
 
         emitEvent?.('run_completed', {

package/src/release/commit-message.mjs

@@ -20,7 +20,8 @@ const GENERIC_SUBJECT_PATTERNS = [
   /^update work$/i,
   /^misc(ellaneous)?( updates?)?$/i,
   /^changes$/i,
-  /^updates?$/i
+  /^updates?$/i,
+  /^(improve|update|adjust|refine|align|support|enable)\s+.+\s+(workflow|process|flow)$/i
 ]
 const MAX_WORKING_TREE_PREVIEW = 20
 const STATUS_LABELS = {
@@ -32,59 +33,6 @@ const STATUS_LABELS = {
   T: 'type-changed',
   U: 'conflicted'
 }
-const TOPIC_STOP_WORDS = new Set([
-  'src',
-  'test',
-  'tests',
-  '__tests__',
-  'spec',
-  'specs',
-  'app',
-  'lib',
-  'dist',
-  'packages',
-  'package',
-  'application',
-  'shared',
-  'index',
-  'main',
-  'local',
-  'repo',
-  'prepare',
-  'commit',
-  'message',
-  'js',
-  'jsx',
-  'ts',
-  'tsx',
-  'mjs',
-  'cjs',
-  'php',
-  'json',
-  'yaml',
-  'yml',
-  'md',
-  'toml',
-  'lock'
-])
-
-function buildTargetedFallbackCommitMessage(statusEntries = []) {
-  const paths = statusEntries.map((entry) => entry.path.toLowerCase())
-  const touchesDeployPrep = paths.some((pathValue) => pathValue.includes('prepare-local-deployment'))
-  const touchesLocalRepo = paths.some((pathValue) => pathValue.includes('local-repo'))
-  const touchesCommitMessage = paths.some((pathValue) => pathValue.includes('commit-message'))
-  const touchesReleaseFlow = paths.some((pathValue) => pathValue.includes('/release/') || pathValue.includes('release-'))
-
-  if (touchesDeployPrep && touchesLocalRepo) {
-    return 'fix: prompt for dirty deploy changes before version bump'
-  }
-
-  if (touchesCommitMessage && touchesReleaseFlow) {
-    return 'fix: tighten release commit suggestions'
-  }
-
-  return null
-}
 
 function resolveWorkingTreeEntryLabel(entry) {
   if (entry.indexStatus === '?' && entry.worktreeStatus === '?') {
@@ -105,32 +53,6 @@ function resolveWorkingTreeEntryLabel(entry) {
   return 'changed'
 }
 
-function tokenizePath(pathValue = '') {
-  return pathValue
-    .split(/[\\/]/)
-    .flatMap((segment) => segment.split(/[^a-zA-Z0-9]+/))
-    .map((token) => token.toLowerCase())
-    .filter((token) => token.length >= 3 && !TOPIC_STOP_WORDS.has(token))
-}
-
-function inferCommitTypeFromEntries(statusEntries = []) {
-  const paths = statusEntries.map((entry) => entry.path.toLowerCase())
-
-  if (paths.every((pathValue) => pathValue.endsWith('.md') || pathValue.includes('/docs/') || pathValue.startsWith('docs/'))) {
-    return 'docs'
-  }
-
-  if (paths.every((pathValue) => /\.test\.[^.]+$/.test(pathValue) || pathValue.includes('/tests/'))) {
-    return 'test'
-  }
-
-  if (paths.some((pathValue) => pathValue.includes('.github/workflows/') || pathValue.includes('/ci/'))) {
-    return 'ci'
-  }
-
-  return 'chore'
-}
-
 export function parseWorkingTreeStatus(stdout = '') {
   return stdout
     .split(/\r?\n/)
@@ -225,92 +147,11 @@ export function sanitizeSuggestedCommitMessage(message) {
   return normalized
 }
 
-export function buildFallbackCommitMessage(statusEntries = []) {
-  const targetedFallback = buildTargetedFallbackCommitMessage(statusEntries)
-  if (targetedFallback) {
-    return targetedFallback
-  }
-
-  const tokenCounts = new Map()
-
-  for (const entry of statusEntries) {
-    for (const token of tokenizePath(entry.path)) {
-      tokenCounts.set(token, (tokenCounts.get(token) ?? 0) + 1)
-    }
-  }
-
-  const orderedTokens = Array.from(tokenCounts.entries())
-    .sort((left, right) => {
-      if (right[1] !== left[1]) {
-        return right[1] - left[1]
-      }
-
-      return left[0].localeCompare(right[0])
-    })
-    .map(([token]) => token)
-
-  const primaryTopic = orderedTokens[0] ?? 'release'
-  const commitType = inferCommitTypeFromEntries(statusEntries)
-
-  if (commitType === 'docs') {
-    return `docs: update ${primaryTopic} documentation`
-  }
-
-  if (commitType === 'test') {
-    return `test: expand ${primaryTopic} coverage`
-  }
-
-  if (commitType === 'ci') {
-    return `ci: update ${primaryTopic} workflow`
-  }
-
-  return `chore: improve ${primaryTopic} workflow`
-}
-
-async function collectDiffNumstat(rootDir, {runCommand} = {}) {
-  try {
-    const {stdout} = await runCommand('git', ['diff', '--numstat', 'HEAD', '--'], {
-      capture: true,
-      cwd: rootDir
-    })
-
-    return stdout
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter(Boolean)
-      .reduce((map, line) => {
-        const [addedRaw, deletedRaw, filePath] = line.split('\t')
-        if (!filePath) {
-          return map
-        }
-
-        const added = Number.parseInt(addedRaw, 10)
-        const deleted = Number.parseInt(deletedRaw, 10)
-        map.set(filePath, {
-          added: Number.isFinite(added) ? added : 0,
-          deleted: Number.isFinite(deleted) ? deleted : 0
-        })
-        return map
-      }, new Map())
-  } catch {
-    return new Map()
-  }
-}
-
-async function buildCommitMessageContext(rootDir, {
-  runCommand,
-  statusEntries = []
-} = {}) {
-  const changeCountsByPath = await collectDiffNumstat(rootDir, {runCommand})
-  return statusEntries.map((entry) => `- ${summarizeWorkingTreeEntry(entry, {changeCountsByPath})}`).join('\n')
-}
-
 export async function suggestCommitMessage(rootDir = process.cwd(), {
   runCommand,
   commandExistsImpl = commandExists,
   logStep,
-  logWarning,
-  statusEntries = []
+  logWarning
 } = {}) {
   if (!commandExistsImpl('codex')) {
     return null
@@ -321,10 +162,6 @@ export async function suggestCommitMessage(rootDir = process.cwd(), {
   try {
     tempDir = await mkdtemp(path.join(tmpdir(), 'zephyr-release-commit-'))
     const outputPath = path.join(tempDir, 'codex-last-message.txt')
-    const commitContext = await buildCommitMessageContext(rootDir, {
-      runCommand,
-      statusEntries
-    })
 
     logStep?.('Generating a suggested commit message with Codex...')
 
@@ -339,13 +176,11 @@ export async function suggestCommitMessage(rootDir = process.cwd(), {
       '--output-last-message',
       outputPath,
       [
-        'Write exactly one short conventional commit message for these pending changes.',
-        'Use the exact format "<type>: <subject>" with no scope, no exclamation mark, and no extra text.',
-        'Choose the most appropriate type from: fix, feat, chore, docs, refactor, test, style, perf, build, ci, revert.',
-        'Make the subject specific enough to describe the actual behavior or workflow change, not just that files changed.',
-        'Do not describe the commit itself, staging, or "pending changes"; describe the underlying behavior or workflow fix.',
-        'Pending change summary:',
-        commitContext || '- changed files present'
+        'Inspect the current repository and decide the best conventional commit message for the pending changes.',
+        'Use whatever read-only inspection you need.',
+        'Reply with exactly one line in the format "<type>: <subject>".',
+        'Do not use scopes like "fix(scope): ...".',
+        'Do not include extra text.'
       ].join('\n\n')
     ], {
       capture: true,

package/src/release/shared.mjs

@@ -10,7 +10,6 @@ import {
   getUpstreamRef
 } from '../utils/git.mjs'
 import {
-  buildFallbackCommitMessage,
   formatWorkingTreePreview,
   parseWorkingTreeEntries,
   parseWorkingTreeStatus,
@@ -117,35 +116,24 @@ export async function ensureCleanWorkingTree(rootDir = process.cwd(), {
     logStep,
     logWarning,
     statusEntries
-  }) ?? buildFallbackCommitMessage(statusEntries)
-
-  const changeLabel = statusEntries.length === 1 ? 'change' : 'changes'
-  const {shouldCommitPendingChanges} = await runPrompt([
+  })
+  const {commitMessage} = await runPrompt([
     {
-      type: 'confirm',
-      name: 'shouldCommitPendingChanges',
+      type: 'input',
+      name: 'commitMessage',
       message:
-        `Pending ${changeLabel} detected before release:\n\n` +
+        'Pending changes detected before release:\n\n' +
         `${formatWorkingTreePreview(statusEntries)}\n\n` +
-        'Stage and commit all current changes before continuing?',
-      default: true
+        'Enter a commit message to stage and commit all current changes before continuing.\n' +
+        'Leave blank to cancel.',
+      default: suggestedCommitMessage ?? ''
     }
   ])
 
-  if (!shouldCommitPendingChanges) {
+  if (!commitMessage || commitMessage.trim().length === 0) {
     throw new Error(DIRTY_WORKING_TREE_CANCELLED_MESSAGE)
   }
 
-  const {commitMessage} = await runPrompt([
-    {
-      type: 'input',
-      name: 'commitMessage',
-      message: 'Commit message for pending release changes',
-      default: suggestedCommitMessage,
-      validate: (value) => (value && value.trim().length > 0 ? true : 'Commit message cannot be empty.')
-    }
-  ])
-
   const message = commitMessage.trim()
 
   logStep?.('Staging all pending changes before release...')

package/src/release-node.mjs

@@ -9,6 +9,7 @@ function hasExplicitReleaseOptions(options = {}) {
         'skipGitHooks',
         'skipTests',
         'skipLint',
+        'skipVersioning',
         'skipBuild',
         'skipDeploy'
     ].some((key) => key in options)
@@ -21,12 +22,17 @@ export async function releaseNode(options = {}) {
             skipGitHooks: options.skipGitHooks === true,
             skipTests: options.skipTests === true,
             skipLint: options.skipLint === true,
+            skipVersioning: options.skipVersioning === true,
             skipBuild: options.skipBuild === true,
             skipDeploy: options.skipDeploy === true
         }
         : parseReleaseArgs({
-            booleanFlags: ['--skip-git-hooks', '--skip-tests', '--skip-lint', '--skip-build', '--skip-deploy']
+            booleanFlags: ['--skip-git-hooks', '--skip-tests', '--skip-lint', '--skip-versioning', '--skip-build', '--skip-deploy']
         })
+
+    if (parsed.skipVersioning && parsed.releaseType) {
+        throw new Error('--skip-versioning cannot be used together with an explicit version or bump argument.')
+    }
     const rootDir = options.rootDir ?? process.cwd()
     const context = options.context ?? createAppContext({
         executionMode: {
@@ -42,6 +48,7 @@ export async function releaseNode(options = {}) {
         skipGitHooks: parsed.skipGitHooks === true || executionMode?.skipGitHooks === true,
         skipTests: parsed.skipTests === true,
         skipLint: parsed.skipLint === true,
+        skipVersioning: parsed.skipVersioning === true,
         skipBuild: parsed.skipBuild === true,
         skipDeploy: parsed.skipDeploy === true,
         rootDir,