@wyxos/zephyr 0.5.0 → 0.7.4

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

@@ -50,28 +50,58 @@ async function resolveSupportedLaravelTestCommand(rootDir, {runCommandCapture} =
 export async function resolveLocalDeploymentCheckSupport({
     rootDir,
     isLaravel,
+    skipTests = false,
+    skipLint = false,
     runCommandCapture
 } = {}) {
     let lintCommand = null
 
-    try {
-        lintCommand = await preflight.resolveSupportedLintCommand(rootDir, {commandExists})
-    } catch (error) {
-        if (error?.code !== 'ZEPHYR_LINT_COMMAND_NOT_FOUND') {
-            throw error
+    if (!skipLint) {
+        try {
+            lintCommand = await preflight.resolveSupportedLintCommand(rootDir, {commandExists})
+        } catch (error) {
+            if (error?.code !== 'ZEPHYR_LINT_COMMAND_NOT_FOUND') {
+                throw error
+            }
         }
     }
 
-    const testCommand = isLaravel
+    const buildCommand = isLaravel && !skipTests
+        ? await preflight.resolveSupportedBuildCommand(rootDir, {commandExists})
+        : null
+
+    const testCommand = isLaravel && !skipTests
         ? await resolveSupportedLaravelTestCommand(rootDir, {runCommandCapture})
         : null
 
     return {
         lintCommand,
+        buildCommand,
         testCommand
     }
 }
 
+async function runLocalLaravelBuild(rootDir, {runCommand, logProcessing, logSuccess, buildCommand} = {}) {
+    try {
+        await preflight.runBuild(rootDir, {
+            runCommand,
+            logProcessing,
+            logSuccess,
+            commandExists,
+            buildCommand
+        })
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(
+                'Failed to run local frontend build: npm executable not found.\n' +
+                'Make sure npm is installed and available in your PATH.'
+            )
+        }
+
+        throw new Error(`Local frontend build failed. Fix build failures before deploying.\n${error.message}`)
+    }
+}
+
 async function runLocalLaravelTests(rootDir, {runCommand, logProcessing, logSuccess, testCommand} = {}) {
     logProcessing?.('Running Laravel tests locally...')
 
@@ -95,19 +125,25 @@ export async function runLocalDeploymentChecks({
     isLaravel,
     hasHook,
     skipGitHooks = false,
+    skipTests = false,
+    skipLint = false,
+    forceRunWhenHookPresent = false,
     runCommand,
     runCommandCapture,
     logProcessing,
     logSuccess,
     logWarning,
     lintCommand = undefined,
+    buildCommand = undefined,
     testCommand = undefined
 } = {}) {
-    const support = lintCommand !== undefined || testCommand !== undefined
-        ? {lintCommand, testCommand}
+    const support = lintCommand !== undefined || buildCommand !== undefined || testCommand !== undefined
+        ? {lintCommand, buildCommand, testCommand}
         : await resolveLocalDeploymentCheckSupport({
             rootDir,
             isLaravel,
+            skipTests,
+            skipLint,
             runCommandCapture
         })
 
@@ -116,6 +152,10 @@ export async function runLocalDeploymentChecks({
             logWarning?.(
                 'Pre-push git hook detected. Zephyr will run its built-in release checks manually because --skip-git-hooks is enabled, and the hook will be bypassed during git push.'
             )
+        } else if (forceRunWhenHookPresent) {
+            logProcessing?.(
+                'Pre-push git hook detected. Zephyr will run its built-in release checks now before bumping the deployment version. The hook will still run again during git push.'
+            )
         } else {
             logProcessing?.(
                 'Pre-push git hook detected. Built-in release checks are supported, but Zephyr will skip executing them here. If Zephyr pushes local commits during this release, the hook will run during git push.'
@@ -124,11 +164,19 @@ export async function runLocalDeploymentChecks({
         }
     }
 
-    if (support.lintCommand === null) {
+    if (hasHook && !skipGitHooks && (skipLint || skipTests)) {
+        logWarning?.(
+            'Pre-push git hook detected. --skip-lint/--skip-tests only skip Zephyr\'s built-in checks; your hook may still run its own checks during git push.'
+        )
+    }
+
+    if (skipLint) {
+        logWarning?.('Skipping lint because --skip-lint flag was provided.')
+    } else if (support.lintCommand === null) {
         logWarning?.('No supported lint command was found. Skipping linting checks.')
     }
 
-    const lintRan = support.lintCommand === null
+    const lintRan = skipLint || support.lintCommand === null
         ? false
         : await preflight.runLinting(rootDir, {
             runCommand,
@@ -152,7 +200,18 @@ export async function runLocalDeploymentChecks({
         }
     }
 
-    if (isLaravel) {
+    if (isLaravel && skipTests) {
+        logWarning?.('Skipping tests because --skip-tests flag was provided.')
+    } else if (isLaravel) {
+        if (support.buildCommand) {
+            await runLocalLaravelBuild(rootDir, {
+                runCommand,
+                logProcessing,
+                logSuccess,
+                buildCommand: support.buildCommand
+            })
+        }
+
         await runLocalLaravelTests(rootDir, {
             runCommand,
             logProcessing,

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,9 +40,12 @@ 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-tests', 'Skip test execution in package release workflows.')
-        .option('--skip-lint', 'Skip lint execution in package release workflows.')
+        .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.')
+        .option('--skip-lint', 'Skip Zephyr local lint execution in package release and app deployment workflows.')
         .option('--skip-build', 'Skip build execution in node/vue release workflows.')
         .option('--skip-deploy', 'Skip GitHub Pages deployment in node/vue release workflows.')
         .argument(
@@ -53,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.')
@@ -67,11 +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),
-        skipTests: Boolean(options.skipTests),
-        skipLint: Boolean(options.skipLint),
+        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
     }
 }
 
@@ -84,8 +103,8 @@ export function validateCliOptions(options = {}) {
         resumePending = false,
         discardPending = false,
         maintenanceMode = null,
-        skipTests = false,
-        skipLint = false,
+        autoCommit = false,
+        skipVersioning = false,
         skipBuild = false,
         skipDeploy = false
     } = options
@@ -112,13 +131,21 @@ 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 (skipTests || skipLint || skipBuild || skipDeploy) {
-            throw new InvalidCliOptionsError('Release-only skip flags are not valid for app deployments.')
+        if (skipBuild || skipDeploy) {
+            throw new InvalidCliOptionsError('--skip-build and --skip-deploy are only valid for node/vue release workflows.')
         }
 
         if (nonInteractive && !presetName) {
             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 }