@wyxos/zephyr 0.4.7 → 0.4.9

package/package.json

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

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

@@ -1,6 +1,6 @@
 import process from 'node:process'
 
-import {ensureLocalRepositoryState} from '../../deploy/local-repo.mjs'
+import {ensureCommittedChangesPushed, ensureLocalRepositoryState} from '../../deploy/local-repo.mjs'
 import {bumpLocalPackageVersion} from './bump-local-package-version.mjs'
 import {resolveLocalDeploymentContext} from './resolve-local-deployment-context.mjs'
 import {resolveLocalDeploymentCheckSupport, runLocalDeploymentChecks} from './run-local-deployment-checks.mjs'
@@ -17,6 +17,16 @@ export async function prepareLocalDeployment(config, {
     logSuccess,
     logWarning
 } = {}) {
+    await ensureLocalRepositoryState(config.branch, rootDir, {
+        runPrompt,
+        runCommand,
+        runCommandCapture,
+        logProcessing,
+        logSuccess,
+        logWarning,
+        skipGitHooks
+    })
+
     const context = await resolveLocalDeploymentContext(rootDir)
     const checkSupport = await resolveLocalDeploymentCheckSupport({
         rootDir,
@@ -33,17 +43,16 @@ export async function prepareLocalDeployment(config, {
             logSuccess,
             logWarning
         })
-    }
 
-    await ensureLocalRepositoryState(config.branch, rootDir, {
-        runPrompt,
-        runCommand,
-        runCommandCapture,
-        logProcessing,
-        logSuccess,
-        logWarning,
-        skipGitHooks
-    })
+        await ensureCommittedChangesPushed(config.branch, rootDir, {
+            runCommand,
+            runCommandCapture,
+            logProcessing,
+            logSuccess,
+            logWarning,
+            skipGitHooks
+        })
+    }
 
     await runLocalDeploymentChecks({
         rootDir,

package/src/deploy/local-repo.mjs

@@ -1,6 +1,15 @@
 import { getCurrentBranch as getCurrentBranchImpl, getUpstreamRef as getUpstreamRefImpl } from '../utils/git.mjs'
 import {hasPrePushHook} from './preflight.mjs'
 import {gitCommitArgs, gitPushArgs} from '../utils/git-hooks.mjs'
+import {
+  buildFallbackCommitMessage,
+  formatWorkingTreePreview,
+  parseWorkingTreeEntries,
+  suggestCommitMessage as suggestCommitMessageImpl
+} from '../release/commit-message.mjs'
+
+const DIRTY_DEPLOYMENT_MESSAGE = 'Local repository has uncommitted changes. Commit or stash them before deployment.'
+const DIRTY_DEPLOYMENT_CANCELLED_MESSAGE = 'Deployment cancelled: pending changes were not committed.'
 
 export async function getCurrentBranch(rootDir) {
   const branch = await getCurrentBranchImpl(rootDir)
@@ -161,27 +170,84 @@ async function checkoutTargetBranch(targetBranch, currentBranch, rootDir, {
   logSuccess?.(`Checked out ${targetBranch} locally.`)
 }
 
-async function commitAndPushStagedChanges(targetBranch, rootDir, {
+async function commitAndPushPendingChanges(targetBranch, rootDir, {
   runPrompt,
   runCommand,
+  runCommandCapture,
   getGitStatus,
   logProcessing,
   logSuccess,
   logWarning,
-  skipGitHooks = false
+  skipGitHooks = false,
+  suggestCommitMessage = suggestCommitMessageImpl
 } = {}) {
+  const statusEntries = parseWorkingTreeEntries(await getGitStatus(rootDir))
+
+  if (statusEntries.length === 0) {
+    return
+  }
+
+  if (typeof runPrompt !== 'function') {
+    throw new Error(DIRTY_DEPLOYMENT_MESSAGE)
+  }
+
+  const captureAwareRunCommand = async (command, args, { capture = false, cwd } = {}) => {
+    if (capture) {
+      const captured = await runCommandCapture(command, args, { cwd })
+
+      if (typeof captured === 'string') {
+        return {stdout: captured.trim(), stderr: ''}
+      }
+
+      const stdout = captured?.stdout ?? ''
+      const stderr = captured?.stderr ?? ''
+      return {stdout: stdout.trim(), stderr: stderr.trim()}
+    }
+
+    await runCommand(command, args, { cwd })
+    return undefined
+  }
+
+  const suggestedCommitMessage = await suggestCommitMessage(rootDir, {
+    runCommand: captureAwareRunCommand,
+    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
+    }
+  ])
+
+  if (!shouldCommitPendingChanges) {
+    throw new Error(DIRTY_DEPLOYMENT_CANCELLED_MESSAGE)
+  }
+
   const { commitMessage } = await runPrompt([
     {
       type: 'input',
       name: 'commitMessage',
-      message: 'Enter a commit message for pending changes before deployment',
+      message: 'Commit message for pending deployment changes',
+      default: suggestedCommitMessage,
       validate: (value) => (value && value.trim().length > 0 ? true : 'Commit message cannot be empty.')
     }
   ])
 
   const message = commitMessage.trim()
 
-  logProcessing?.('Committing staged changes before deployment...')
+  logProcessing?.('Staging all pending changes before deployment...')
+  await runCommand('git', ['add', '-A'], { cwd: rootDir })
+
+  logProcessing?.('Committing pending changes before deployment...')
   await runCommand('git', gitCommitArgs(['-m', message], {skipGitHooks}), { cwd: rootDir })
 
   const prePushHookPresent = await hasPrePushHook(rootDir)
@@ -203,7 +269,8 @@ async function commitAndPushStagedChanges(targetBranch, rootDir, {
     throw error
   }
 
-  logSuccess?.(`Committed and pushed changes to origin/${targetBranch}.`)
+  logSuccess?.(`Committed pending changes with "${message}".`)
+  logSuccess?.(`Pushed committed changes to origin/${targetBranch}.`)
 
   const finalStatus = await getGitStatus(rootDir)
 
@@ -303,6 +370,7 @@ export async function ensureLocalRepositoryState(targetBranch, rootDir = process
   logSuccess,
   logWarning,
   skipGitHooks = false,
+  suggestCommitMessage: suggestCommitMessageFn = suggestCommitMessageImpl,
   getCurrentBranch: getCurrentBranchFn = getCurrentBranch,
   getGitStatus: getGitStatusFn = (dir) => getGitStatus(dir, { runCommandCapture }),
   readUpstreamSyncState: readUpstreamSyncStateFn = (branch, dir) =>
@@ -371,21 +439,17 @@ export async function ensureLocalRepositoryState(targetBranch, rootDir = process
     return
   }
 
-  if (!hasStagedChanges(statusAfterCheckout)) {
-    await ensureCommittedChangesPushedFn(targetBranch, rootDir)
-    logProcessing?.('No staged changes detected. Unstaged or untracked files will not affect deployment. Proceeding with deployment.')
-    return
-  }
-
-  logWarning?.(`Staged changes detected on ${targetBranch}. A commit is required before deployment.`)
-  await commitAndPushStagedChanges(targetBranch, rootDir, {
+  logWarning?.(`Pending changes detected on ${targetBranch}. A commit is required before deployment.`)
+  await commitAndPushPendingChanges(targetBranch, rootDir, {
     runPrompt,
     runCommand,
+    runCommandCapture,
     getGitStatus: getGitStatusFn,
     logProcessing,
     logSuccess,
     logWarning,
-    skipGitHooks
+    skipGitHooks,
+    suggestCommitMessage: suggestCommitMessageFn
   })
 
   await ensureCommittedChangesPushedFn(targetBranch, rootDir)

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/commit-message.mjs

@@ -9,6 +9,11 @@ const CONVENTIONAL_COMMIT_PATTERN = /^(build|chore|ci|docs|feat|fix|perf|refacto
 const GENERIC_SUBJECT_PATTERNS = [
   /^commit pending (release )?changes$/i,
   /^pending (release )?changes$/i,
+  /^commit pending changes before .+$/i,
+  /^commit pending (release |deployment )?changes before .+$/i,
+  /^commit (all )?(current |pending )?changes( before .+)?$/i,
+  /^stage and commit (all )?(current |pending )?changes( before .+)?$/i,
+  /^(allow|enable|support) committing pending changes( before .+)?$/i,
   /^commit changes$/i,
   /^update changes$/i,
   /^update files$/i,
@@ -43,6 +48,11 @@ const TOPIC_STOP_WORDS = new Set([
   'shared',
   'index',
   'main',
+  'local',
+  'repo',
+  'prepare',
+  'commit',
+  'message',
   'js',
   'jsx',
   'ts',
@@ -58,6 +68,24 @@ const TOPIC_STOP_WORDS = new Set([
   '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 === '?') {
     return 'untracked'
@@ -198,6 +226,11 @@ export function sanitizeSuggestedCommitMessage(message) {
 }
 
 export function buildFallbackCommitMessage(statusEntries = []) {
+  const targetedFallback = buildTargetedFallbackCommitMessage(statusEntries)
+  if (targetedFallback) {
+    return targetedFallback
+  }
+
   const tokenCounts = new Map()
 
   for (const entry of statusEntries) {
@@ -272,7 +305,7 @@ async function buildCommitMessageContext(rootDir, {
   return statusEntries.map((entry) => `- ${summarizeWorkingTreeEntry(entry, {changeCountsByPath})}`).join('\n')
 }
 
-export async function suggestReleaseCommitMessage(rootDir = process.cwd(), {
+export async function suggestCommitMessage(rootDir = process.cwd(), {
   runCommand,
   commandExistsImpl = commandExists,
   logStep,
@@ -310,6 +343,7 @@ export async function suggestReleaseCommitMessage(rootDir = process.cwd(), {
         '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'
       ].join('\n\n')
@@ -329,3 +363,5 @@ export async function suggestReleaseCommitMessage(rootDir = process.cwd(), {
     }
   }
 }
+
+export {suggestCommitMessage as suggestReleaseCommitMessage}

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
+  }
+}