@eldrforge/kodrdriv 1.2.4 → 1.2.6

package/dist/commands/publish.js

@@ -7,7 +7,7 @@ import { runWithDryRunSupport, run, validateGitRef, runSecure } from '../util/ch
 import { getCurrentBranchName, findOpenPullRequestByHeadRef, createPullRequest, waitForPullRequestChecks, mergePullRequest, createRelease, closeMilestoneForVersion, getWorkflowsTriggeredByRelease, waitForReleaseWorkflows } from '../util/github.js';
 import { create } from '../util/storage.js';
 import { calculateTargetVersion, checkIfTagExists, confirmVersionInteractively, getOutputPath } from '../util/general.js';
-import { DEFAULT_OUTPUT_DIRECTORY } from '../constants.js';
+import { DEFAULT_OUTPUT_DIRECTORY, KODRDRIV_DEFAULTS } from '../constants.js';
 import { safeJsonParse, validatePackageJson } from '../util/validation.js';
 import { safeSyncBranchWithRemote, localBranchExists, isBranchInSyncWithRemote } from '../util/git.js';
 
@@ -189,6 +189,85 @@ const runPrechecks = async (runConfig)=>{
     }
     logger.info('All prechecks passed.');
 };
+// Helper: deep-sort object keys for stable comparison
+const sortObjectKeys = (value)=>{
+    if (Array.isArray(value)) {
+        return value.map(sortObjectKeys);
+    }
+    if (value && typeof value === 'object') {
+        const sorted = {};
+        Object.keys(value).sort().forEach((key)=>{
+            sorted[key] = sortObjectKeys(value[key]);
+        });
+        return sorted;
+    }
+    return value;
+};
+// Determine if there are substantive changes compared to the target branch (beyond just version bump)
+const isReleaseNecessaryComparedToTarget = async (targetBranch, isDryRun)=>{
+    const logger = getDryRunLogger(isDryRun);
+    // We compare current HEAD branch to the provided target branch
+    const currentBranch = await getCurrentBranchName();
+    // If branches are identical, nothing to release
+    const { stdout: namesStdout } = await runSecure('git', [
+        'diff',
+        '--name-only',
+        `${targetBranch}..${currentBranch}`
+    ]);
+    const changedFiles = namesStdout.split('\n').map((s)=>s.trim()).filter(Boolean);
+    if (changedFiles.length === 0) {
+        // No definitive signal; proceed with publish rather than skipping
+        return {
+            necessary: true,
+            reason: 'No detectable changes via diff; proceeding conservatively'
+        };
+    }
+    // If any files changed other than package.json or package-lock.json, a release is necessary
+    const nonVersionFiles = changedFiles.filter((f)=>f !== 'package.json' && f !== 'package-lock.json');
+    if (nonVersionFiles.length > 0) {
+        return {
+            necessary: true,
+            reason: `Changed files beyond version bump: ${nonVersionFiles.join(', ')}`
+        };
+    }
+    // Only package.json and/or package-lock.json changed. Verify package.json change is only the version field
+    try {
+        // Read package.json content from both branches
+        const { stdout: basePkgStdout } = await runSecure('git', [
+            'show',
+            `${targetBranch}:package.json`
+        ]);
+        const { stdout: headPkgStdout } = await runSecure('git', [
+            'show',
+            `${currentBranch}:package.json`
+        ]);
+        const basePkg = validatePackageJson(safeJsonParse(basePkgStdout, `${targetBranch}:package.json`), `${targetBranch}:package.json`);
+        const headPkg = validatePackageJson(safeJsonParse(headPkgStdout, `${currentBranch}:package.json`), `${currentBranch}:package.json`);
+        const { version: _baseVersion, ...baseWithoutVersion } = basePkg;
+        const { version: _headVersion, ...headWithoutVersion } = headPkg;
+        const baseSorted = sortObjectKeys(baseWithoutVersion);
+        const headSorted = sortObjectKeys(headWithoutVersion);
+        const equalExceptVersion = JSON.stringify(baseSorted) === JSON.stringify(headSorted);
+        if (equalExceptVersion) {
+            return {
+                necessary: false,
+                reason: 'Only version changed in package.json (plus lockfile)'
+            };
+        }
+        // Other fields changed inside package.json
+        return {
+            necessary: true,
+            reason: 'package.json changes beyond version field'
+        };
+    } catch (error) {
+        // Conservative: if we cannot prove it is only a version change, proceed with release
+        logger.verbose(`Could not conclusively compare package.json changes: ${error.message}`);
+        return {
+            necessary: true,
+            reason: 'Could not compare package.json safely'
+        };
+    }
+};
 const handleTargetBranchSyncRecovery = async (runConfig)=>{
     var _runConfig_publish;
     const isDryRun = runConfig.dryRun || false;
@@ -233,6 +312,22 @@ const execute = async (runConfig)=>{
     }
     // Run prechecks before starting any work
     await runPrechecks(runConfig);
+    // Early check: determine if a release is necessary compared to target branch
+    logger.info('Evaluating if a release is necessary compared to target branch...');
+    try {
+        const necessity = await isReleaseNecessaryComparedToTarget(targetBranch, isDryRun);
+        if (!necessity.necessary) {
+            logger.info(`Skipping publish: ${necessity.reason}.`);
+            // Emit a machine-readable marker so tree mode can detect skip and avoid propagating versions
+            logger.info('KODRDRIV_PUBLISH_SKIPPED');
+            return;
+        } else {
+            logger.verbose(`Proceeding with publish: ${necessity.reason}.`);
+        }
+    } catch (error) {
+        // On unexpected errors, proceed with publish to avoid false negatives blocking releases
+        logger.verbose(`Release necessity check encountered an issue (${error.message}). Proceeding with publish.`);
+    }
     logger.info('Starting release process...');
     let pr = null;
     if (isDryRun) {
@@ -245,33 +340,57 @@ const execute = async (runConfig)=>{
     if (pr) {
         logger.info(`Found existing pull request for branch: ${pr.html_url}`);
     } else {
-        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6;
+        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6, _runConfig_publish7;
         logger.info('No open pull request found, starting new release publishing process...');
-        // STEP 1: Determine and set target version FIRST (before any commits)
+        // STEP 1: Prepare for release (update dependencies and run prepublish checks) with NO version bump yet
+        logger.verbose('Preparing for release: switching from workspace to remote dependencies.');
+        logger.verbose('Updating dependencies to latest versions from registry');
+        const updatePatterns = (_runConfig_publish4 = runConfig.publish) === null || _runConfig_publish4 === void 0 ? void 0 : _runConfig_publish4.dependencyUpdatePatterns;
+        if (updatePatterns && updatePatterns.length > 0) {
+            logger.verbose(`Updating dependencies matching patterns: ${updatePatterns.join(', ')}`);
+            const patternsArg = updatePatterns.join(' ');
+            await runWithDryRunSupport(`npm update ${patternsArg}`, isDryRun);
+        } else {
+            logger.verbose('No dependency update patterns specified, updating all dependencies');
+            await runWithDryRunSupport('npm update', isDryRun);
+        }
+        logger.info('Running prepublishOnly script...');
+        await runWithDryRunSupport('npm run prepublishOnly', isDryRun, {}, true); // Use inherited stdio
+        // STEP 2: Commit dependency updates if any (still no version bump)
+        logger.verbose('Staging dependency updates for commit');
+        await runWithDryRunSupport('git add package.json package-lock.json', isDryRun);
+        logger.verbose('Checking for staged dependency updates...');
+        if (isDryRun) {
+            logger.verbose('Would create dependency update commit if changes are staged');
+        } else {
+            if (await hasStagedChanges()) {
+                logger.verbose('Staged dependency changes found, creating commit...');
+                await execute$1(runConfig);
+            } else {
+                logger.verbose('No dependency changes to commit, skipping commit.');
+            }
+        }
+        // STEP 3: Determine and set target version AFTER checks and dependency commit
         logger.info('Determining target version...');
         let newVersion;
         if (isDryRun) {
             logger.info('Would determine target version and update package.json');
             newVersion = '1.0.0'; // Mock version for dry run
         } else {
-            var _runConfig_publish7, _runConfig_publish8;
+            var _runConfig_publish8, _runConfig_publish9;
             const packageJsonContents = await storage.readFile('package.json', 'utf-8');
             const parsed = safeJsonParse(packageJsonContents, 'package.json');
             const packageJson = validatePackageJson(parsed, 'package.json');
             const currentVersion = packageJson.version;
-            // Determine target version based on --targetVersion option
-            const targetVersionInput = ((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.targetVersion) || 'patch';
+            const targetVersionInput = ((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.targetVersion) || 'patch';
             const proposedVersion = calculateTargetVersion(currentVersion, targetVersionInput);
-            // Check if target tag already exists
             const targetTagName = `v${proposedVersion}`;
             const tagExists = await checkIfTagExists(targetTagName);
             if (tagExists) {
                 throw new Error(`Tag ${targetTagName} already exists. Please choose a different version or delete the existing tag.`);
             }
-            // Interactive confirmation if --interactive flag is set
-            if ((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.interactive) {
+            if ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.interactive) {
                 newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, targetVersionInput);
-                // Re-check if the confirmed version's tag exists (in case user entered custom version)
                 const confirmedTagName = `v${newVersion}`;
                 const confirmedTagExists = await checkIfTagExists(confirmedTagName);
                 if (confirmedTagExists) {
@@ -281,48 +400,30 @@ const execute = async (runConfig)=>{
                 newVersion = proposedVersion;
             }
             logger.info(`Bumping version from ${currentVersion} to ${newVersion}`);
-            // Update package.json with the new version BEFORE any other operations
             packageJson.version = newVersion;
             await storage.writeFile('package.json', JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
             logger.info(`Version updated in package.json: ${newVersion}`);
         }
-        // STEP 2: Prepare for release (with correct version now in package.json)
-        logger.verbose('Preparing for release: switching from workspace to remote dependencies.');
-        logger.verbose('Updating dependencies to latest versions from registry');
-        const updatePatterns = (_runConfig_publish4 = runConfig.publish) === null || _runConfig_publish4 === void 0 ? void 0 : _runConfig_publish4.dependencyUpdatePatterns;
-        if (updatePatterns && updatePatterns.length > 0) {
-            logger.verbose(`Updating dependencies matching patterns: ${updatePatterns.join(', ')}`);
-            const patternsArg = updatePatterns.join(' ');
-            await runWithDryRunSupport(`npm update ${patternsArg}`, isDryRun);
-        } else {
-            logger.verbose('No dependency update patterns specified, updating all dependencies');
-            await runWithDryRunSupport('npm update', isDryRun);
-        }
-        logger.info('Running prepublishOnly script...');
-        await runWithDryRunSupport('npm run prepublishOnly', isDryRun, {}, true); // Use inherited stdio
-        // STEP 3: Stage all changes (version bump + dependencies + any build artifacts)
-        logger.verbose('Staging all changes for release commit');
+        // STEP 4: Commit version bump as a separate commit
+        logger.verbose('Staging version bump for commit');
         await runWithDryRunSupport('git add package.json package-lock.json', isDryRun);
-        logger.verbose('Checking for staged changes...');
         if (isDryRun) {
-            logger.verbose('Assuming staged changes exist for demo purposes');
-            logger.verbose('Would create commit...');
-            await execute$1(runConfig);
+            logger.verbose('Would create version bump commit');
         } else {
             if (await hasStagedChanges()) {
-                logger.verbose('Staged changes found, creating commit...');
+                logger.verbose('Creating version bump commit...');
                 await execute$1(runConfig);
             } else {
-                logger.verbose('No changes to commit, skipping commit.');
+                logger.verbose('No version changes to commit.');
             }
         }
         logger.info('Generating release notes...');
-        // Create a modified config for release notes generation that includes the publish --from and --interactive options
+        // Create a modified config for release notes generation that includes the publish --from, --interactive, and --from-main options
         const releaseConfig = {
             ...runConfig
         };
-        if (((_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.from) || ((_runConfig_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.interactive)) {
-            // Pass the publish --from and --interactive options to the release config
+        if (((_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.from) || ((_runConfig_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.interactive) || ((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.fromMain)) {
+            // Pass the publish options to the release config
             releaseConfig.release = {
                 ...runConfig.release,
                 ...runConfig.publish.from && {
@@ -330,6 +431,9 @@ const execute = async (runConfig)=>{
                 },
                 ...runConfig.publish.interactive && {
                     interactive: runConfig.publish.interactive
+                },
+                ...runConfig.publish.fromMain && {
+                    fromMain: runConfig.publish.fromMain
                 }
             };
             if (runConfig.publish.from) {
@@ -338,6 +442,9 @@ const execute = async (runConfig)=>{
             if (runConfig.publish.interactive) {
                 logger.verbose('Interactive mode enabled for release notes generation');
             }
+            if (runConfig.publish.fromMain) {
+                logger.verbose('Forcing comparison against main branch for release notes');
+            }
         }
         const releaseSummary = await execute$2(releaseConfig);
         if (isDryRun) {
@@ -374,12 +481,12 @@ const execute = async (runConfig)=>{
     }
     logger.info(`Waiting for PR #${pr.number} checks to complete...`);
     if (!isDryRun) {
-        var _runConfig_publish9, _runConfig_publish10, _runConfig_publish11;
+        var _runConfig_publish10, _runConfig_publish11, _runConfig_publish12;
         // Configure timeout and user confirmation behavior
-        const timeout = ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.checksTimeout) || 300000; // 5 minutes default
-        const senditMode = ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.sendit) || false;
+        const timeout = ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.checksTimeout) || KODRDRIV_DEFAULTS.publish.checksTimeout;
+        const senditMode = ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.sendit) || false;
         // sendit flag overrides skipUserConfirmation - if sendit is true, skip confirmation
-        const skipUserConfirmation = senditMode || ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.skipUserConfirmation) || false;
+        const skipUserConfirmation = senditMode || ((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.skipUserConfirmation) || false;
         await waitForPullRequestChecks(pr.number, {
             timeout,
             skipUserConfirmation
@@ -517,9 +624,9 @@ const execute = async (runConfig)=>{
     }
     logger.info('Creating GitHub release...');
     if (isDryRun) {
-        var _runConfig_publish12;
+        var _runConfig_publish13;
         logger.info('Would read package.json version and create GitHub release with retry logic');
-        const milestonesEnabled = !((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.noMilestones);
+        const milestonesEnabled = !((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.noMilestones);
         if (milestonesEnabled) {
             logger.info('Would close milestone for released version');
         } else {
@@ -535,11 +642,11 @@ const execute = async (runConfig)=>{
         let retries = 3;
         while(retries > 0){
             try {
-                var _runConfig_publish13;
+                var _runConfig_publish14;
                 await createRelease(tagName, releaseTitle, releaseNotesContent);
                 logger.info(`GitHub release created successfully for tag: ${tagName}`);
                 // Close milestone for this version if enabled
-                const milestonesEnabled = !((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.noMilestones);
+                const milestonesEnabled = !((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.noMilestones);
                 if (milestonesEnabled) {
                     logger.info('🏁 Closing milestone for released version...');
                     const version = tagName.replace(/^v/, ''); // Remove 'v' prefix if present
@@ -572,12 +679,12 @@ const execute = async (runConfig)=>{
         if (isDryRun) {
             logger.info('Would monitor GitHub Actions workflows triggered by release');
         } else {
-            var _runConfig_publish14, _runConfig_publish15, _runConfig_publish16, _runConfig_publish17;
-            const workflowTimeout = ((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.releaseWorkflowsTimeout) || 600000; // 10 minutes default
-            const senditMode = ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.sendit) || false;
-            const skipUserConfirmation = senditMode || ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.skipUserConfirmation) || false;
+            var _runConfig_publish15, _runConfig_publish16, _runConfig_publish17, _runConfig_publish18;
+            const workflowTimeout = ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.releaseWorkflowsTimeout) || KODRDRIV_DEFAULTS.publish.releaseWorkflowsTimeout;
+            const senditMode = ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.sendit) || false;
+            const skipUserConfirmation = senditMode || ((_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.skipUserConfirmation) || false;
             // Get workflow names - either from config or auto-detect
-            let workflowNames = (_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.releaseWorkflowNames;
+            let workflowNames = (_runConfig_publish18 = runConfig.publish) === null || _runConfig_publish18 === void 0 ? void 0 : _runConfig_publish18.releaseWorkflowNames;
             if (!workflowNames || workflowNames.length === 0) {
                 logger.info('No specific workflow names configured, auto-detecting workflows triggered by release events...');
                 try {