build(release): update prompt defaults

alandefreitas · alandefreitas · commit 9ce10e3bc356 · 2025-12-16T22:53:59.000-05:00
diff --git a/utils/release/src/prompt.ts b/utils/release/src/prompt.ts
@@ -108,7 +108,8 @@ export async function askConsent(
     description: string,
     command: string,
     skipPrompt: boolean,
-    dryRun: boolean
+    dryRun: boolean,
+    defaultYes = false
 ): Promise<boolean> {
     console.log(`\nAbout to: ${description}`);
     console.log(`Command: ${command}`);
@@ -123,5 +124,5 @@ export async function askConsent(
         return true;
     }
 
-    return askYesNo('Proceed?');
+    return askYesNo('Proceed?', defaultYes);
 }
diff --git a/utils/release/src/release.ts b/utils/release/src/release.ts
@@ -14,11 +14,14 @@ import {
     pushToOrigin,
     rebase,
     getLog,
+    gitSafe,
     GitOptions
 } from './git';
 import { WorktreeContext } from './worktree';
 import { askConsent } from './prompt';
 import { isValidSemver, normalizeTag, extractVersion } from './version';
+import * as fs from 'fs';
+import * as path from 'path';
 
 /**
  * Runs an npm script in the repository root.
@@ -32,6 +35,32 @@ function runNpmScript(script: string, cwd: string): void {
     });
 }
 
+/**
+ * Checks whether all workspaces (including root) already have the target version.
+ * If any package.json is missing or has a different version, returns false.
+ * @param cwd - Repo root
+ * @param targetVersion - Version string without 'v' prefix
+ */
+function packagesAlreadyOnVersion(cwd: string, targetVersion: string): boolean {
+    try {
+        const rootPkgPath = path.join(cwd, 'package.json');
+        const rootPkg = JSON.parse(fs.readFileSync(rootPkgPath, 'utf-8'));
+        const workspaces: string[] = rootPkg.workspaces ?? [];
+        const packageFiles = [rootPkgPath, ...workspaces.map(w => path.join(cwd, w, 'package.json'))];
+
+        for (const pkgPath of packageFiles) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            if (pkg.version !== targetVersion) {
+                return false;
+            }
+        }
+        return true;
+    } catch {
+        // Fall back to running version:set if anything goes wrong
+        return false;
+    }
+}
+
 /**
  * Checks if working tree is clean and prompts user to handle changes.
  * @param gitOpts - Git options
@@ -83,9 +112,11 @@ async function executeStep(
     description: string,
     command: string,
     options: ReleaseOptions,
-    action: () => void
+    action: () => void,
+    defaultYes = true,
+    continueOnFailure = false
 ): Promise<StepResult> {
-    const consent = await askConsent(description, command, options.skipPrompts, options.dryRun);
+    const consent = await askConsent(description, command, options.skipPrompts, options.dryRun, defaultYes);
 
     if (!consent) {
         if (options.dryRun) {
@@ -99,6 +130,10 @@ async function executeStep(
         return { success: true, message: description };
     } catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);
+        if (continueOnFailure) {
+            console.warn(`Non-blocking failure: ${description} - ${errorMessage}`);
+            return { success: true, message: `Non-blocking failure: ${description}` };
+        }
         return { success: false, message: `Failed: ${description} - ${errorMessage}` };
     }
 }
@@ -132,18 +167,23 @@ export async function executeRelease(options: ReleaseOptions): Promise<boolean>
 
     // Pre-release Step 1: Update package versions
     console.log('\n==== Pre-release: Update package versions ====');
-    const versionResult = await executeStep(
-        `Update package.json versions to ${version}`,
-        `npm run version:set -- ${version}`,
-        options,
-        () => runNpmScript(`version:set -- ${version}`, rootDir)
-    );
-    if (!versionResult.success && !dryRun) {
-        console.error(versionResult.message);
-        return false;
-    }
-    if (!dryRun && !requireCleanWorktree(gitOpts, 'Version update')) {
-        return false;
+    const versionsAligned = packagesAlreadyOnVersion(rootDir, version);
+    if (versionsAligned) {
+        console.log(`All packages already at ${version}; skipping version:set.`);
+    } else {
+        const versionResult = await executeStep(
+            `Update package.json versions to ${version}`,
+            `npm run version:set -- ${version}`,
+            options,
+            () => runNpmScript(`version:set -- ${version}`, rootDir)
+        );
+        if (!versionResult.success && !dryRun) {
+            console.error(versionResult.message);
+            return false;
+        }
+        if (!dryRun && !requireCleanWorktree(gitOpts, 'Version update')) {
+            return false;
+        }
     }
 
     // Pre-release Step 2: Rebuild all bundles
@@ -152,7 +192,8 @@ export async function executeRelease(options: ReleaseOptions): Promise<boolean>
         'Regenerate dist outputs for fresh builds',
         'npm run build',
         options,
-        () => runNpmScript('build', rootDir)
+        () => runNpmScript('build', rootDir),
+        true // default Yes; rebuilding should generally proceed
     );
     if (!buildResult.success && !dryRun) {
         console.error(buildResult.message);
@@ -168,7 +209,9 @@ export async function executeRelease(options: ReleaseOptions): Promise<boolean>
         'Run depcheck to verify dependency health',
         'npm run depcheck',
         options,
-        () => runNpmScript('depcheck', rootDir)
+        () => runNpmScript('depcheck', rootDir),
+        true, // default Yes
+        true  // continue even if depcheck reports unused deps
     );
     if (!depcheckResult.success && !dryRun) {
         console.error(depcheckResult.message);
@@ -219,15 +262,45 @@ export async function executeRelease(options: ReleaseOptions): Promise<boolean>
         const remoteDevelop = getCommitSha('origin/develop', gitOpts);
 
         if (localDevelop !== remoteDevelop) {
-            console.error('Local develop branch is not up to date with remote.');
-            console.error(`Local develop:  ${localDevelop}`);
-            console.error(`  ${getCommitMessage('refs/heads/develop', gitOpts)}`);
-            console.error(`Remote develop: ${remoteDevelop}`);
-            console.error(`  ${getCommitMessage('origin/develop', gitOpts)}`);
-            console.error('\nPlease update your local develop branch first.');
-            return false;
+            const remoteIsAncestor = gitSafe(
+                ['merge-base', '--is-ancestor', 'origin/develop', 'refs/heads/develop'],
+                gitOpts
+            );
+            const localIsAncestor = gitSafe(
+                ['merge-base', '--is-ancestor', 'refs/heads/develop', 'origin/develop'],
+                gitOpts
+            );
+
+            if (remoteIsAncestor && !localIsAncestor) {
+                console.log('Local develop is ahead of origin/develop.');
+                console.log(`Local develop:  ${localDevelop}  ${getCommitMessage('refs/heads/develop', gitOpts)}`);
+                console.log(`Remote develop: ${remoteDevelop}  ${getCommitMessage('origin/develop', gitOpts)}`);
+                const pushDevelop = await executeStep(
+                    'Push develop to origin',
+                    'git push origin develop',
+                    options,
+                    () => pushToOrigin('develop', gitOpts),
+                    true // default yes
+                );
+                if (!pushDevelop.success) {
+                    console.error(pushDevelop.message);
+                    return false;
+                }
+            } else if (localIsAncestor && !remoteIsAncestor) {
+                console.error('Local develop is behind origin/develop.');
+                console.error(`Local develop:  ${localDevelop}  ${getCommitMessage('refs/heads/develop', gitOpts)}`);
+                console.error(`Remote develop: ${remoteDevelop}  ${getCommitMessage('origin/develop', gitOpts)}`);
+                console.error('\nPlease pull or rebase develop before releasing.');
+                return false;
+            } else {
+                console.error('Local and origin develop have diverged. Please reconcile before releasing.');
+                console.error(`Local develop:  ${localDevelop}  ${getCommitMessage('refs/heads/develop', gitOpts)}`);
+                console.error(`Remote develop: ${remoteDevelop}  ${getCommitMessage('origin/develop', gitOpts)}`);
+                return false;
+            }
+        } else {
+            console.log(`\u2705 develop branch is up to date (${localDevelop.substring(0, 8)})`);
         }
-        console.log(`\u2705 develop branch is up to date (${localDevelop.substring(0, 8)})`);
     } else {
         console.log('[DRY RUN] Would verify develop matches origin/develop');
     }
@@ -255,6 +328,10 @@ export async function executeRelease(options: ReleaseOptions): Promise<boolean>
         if (!dryRun && worktreeOpts) {
             const masterSha = getCommitSha('HEAD', worktreeOpts);
             const remoteDevelop = getCommitSha('origin/develop', gitOpts);
+            const worktreePath = worktreeContext.getPath();
+            const rebaseCmd = worktreePath
+                ? `git -C ${worktreePath} rebase origin/develop`
+                : 'git rebase origin/develop';
 
             if (masterSha !== remoteDevelop) {
                 console.log('master is not up to date with origin/develop');
@@ -268,8 +345,8 @@ export async function executeRelease(options: ReleaseOptions): Promise<boolean>
                 }
 
                 const rebaseResult = await executeStep(
-                    'Rebase master onto origin/develop',
-                    'git rebase origin/develop',
+                    'Rebase master worktree onto origin/develop (does not touch your local develop)',
+                    rebaseCmd,
                     options,
                     () => rebase('origin/develop', worktreeOpts!)
                 );
diff --git a/utils/release/src/version.ts b/utils/release/src/version.ts
@@ -3,6 +3,8 @@
  */
 
 import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
 import { askChoice, askInput } from './prompt';
 
 /**
@@ -64,6 +66,43 @@ export function formatSemver(version: SemverVersion, includeV = true): string {
     return includeV ? `v${str}` : str;
 }
 
+/**
+ * Compares two semver strings.
+ * @param a - First version (with or without 'v')
+ * @param b - Second version (with or without 'v')
+ * @returns 1 if a>b, -1 if a<b, 0 if equal
+ */
+export function compareSemver(a: string, b: string): number {
+    const va = parseSemver(a);
+    const vb = parseSemver(b);
+
+    if (va.major !== vb.major) return Math.sign(va.major - vb.major);
+    if (va.minor !== vb.minor) return Math.sign(va.minor - vb.minor);
+    return Math.sign(va.patch - vb.patch);
+}
+
+/**
+ * Reads the root package.json version if available.
+ * @param cwd - Working directory
+ * @returns Version with 'v' prefix or null if unavailable/invalid
+ */
+export function getPackageVersion(cwd: string): string | null {
+    try {
+        const pkgPath = path.join(cwd, 'package.json');
+        const contents = fs.readFileSync(pkgPath, 'utf-8');
+        const pkg = JSON.parse(contents);
+        const version = typeof pkg.version === 'string' ? pkg.version : null;
+
+        if (version && isValidSemver(version)) {
+            return normalizeTag(version);
+        }
+    } catch {
+        // Ignore read/parse errors and fall back to git tags
+    }
+
+    return null;
+}
+
 /**
  * Gets the latest tag from the remote repository.
  * @param cwd - Working directory
@@ -134,6 +173,16 @@ export function getFeatureCommitsSince(tag: string, cwd: string): string[] {
  */
 export async function determineVersion(cwd: string): Promise<string> {
     const latestTag = getLatestTag(cwd);
+    const packageVersion = getPackageVersion(cwd);
+
+    if (packageVersion) {
+        if (!latestTag || compareSemver(packageVersion, latestTag) >= 1) {
+            const latestLabel = latestTag ?? 'no remote tag';
+            console.log(`Detected local version ${packageVersion} (latest tag: ${latestLabel}).`);
+            console.log('Using package.json version without suggesting an additional bump.');
+            return packageVersion;
+        }
+    }
 
     if (!latestTag) {
         console.log('No existing tags found on origin. Defaulting to initial release tag v0.1.0.');
diff --git a/utils/release/src/worktree.ts b/utils/release/src/worktree.ts
@@ -40,6 +40,23 @@ export function getWorktreePath(branch: string): string {
 export function createWorktree(branch: string, worktreePath: string, options: GitOptions): WorktreeInfo {
     console.log(`Creating worktree for ${branch} at ${worktreePath}...`);
 
+    // Clean up stale entries and conflicting worktrees for this branch
+    pruneWorktrees(options);
+
+    // If the branch is already checked out in another worktree, try to remove a stale temp worktree
+    const existing = listWorktrees(options).find((wt) => wt.branch === `refs/heads/${branch}`);
+    if (existing) {
+        if (existing.path.includes(`cpp-actions-release-${branch}`)) {
+            console.log(`Found stale ${branch} worktree at ${existing.path}, removing...`);
+            removeWorktree(existing.path, options, true);
+        } else {
+            throw new Error(
+                `Branch ${branch} is already checked out at ${existing.path}. ` +
+                'Please remove or switch that worktree before releasing.'
+            );
+        }
+    }
+
     // Ensure the parent directory exists
     const parentDir = path.dirname(worktreePath);
     if (!fs.existsSync(parentDir)) {
@@ -101,21 +118,31 @@ export function removeWorktree(worktreePath: string, options: GitOptions, force
 }
 
 /**
- * Lists all worktrees.
+ * Lists all worktrees with branch information (if present).
  * @param options - Git options
- * @returns Array of worktree paths
+ * @returns Array of worktree info objects
  */
-export function listWorktrees(options: GitOptions): string[] {
+export function listWorktrees(options: GitOptions): Array<{ path: string; branch: string | null }> {
     const output = git(['worktree', 'list', '--porcelain'], { ...options, silent: true });
-    const paths: string[] = [];
+    const infos: Array<{ path: string; branch: string | null }> = [];
+    let currentPath: string | null = null;
 
     for (const line of output.split('\n')) {
         if (line.startsWith('worktree ')) {
-            paths.push(line.substring(9));
+            currentPath = line.substring(9).trim();
+            infos.push({ path: currentPath, branch: null });
+        } else if (line.startsWith('branch ')) {
+            const branch = line.substring(7).trim();
+            if (currentPath) {
+                const idx = infos.findIndex((w) => w.path === currentPath);
+                if (idx !== -1) {
+                    infos[idx] = { ...infos[idx], branch };
+                }
+            }
         }
     }
 
-    return paths;
+    return infos;
 }
 
 /**
