@eldrforge/kodrdriv 1.2.16 → 1.2.17

package/dist/commands/publish.js

@@ -10,6 +10,7 @@ import { calculateBranchDependentVersion, calculateTargetVersion, checkIfTagExis
 import { DEFAULT_OUTPUT_DIRECTORY, KODRDRIV_DEFAULTS } from '../constants.js';
 import { safeJsonParse, validatePackageJson } from '../util/validation.js';
 import { localBranchExists, safeSyncBranchWithRemote, isBranchInSyncWithRemote } from '../util/git.js';
+import fs__default from 'fs/promises';
 
 const scanNpmrcForEnvVars = async (storage)=>{
     const logger = getLogger();
@@ -38,6 +39,76 @@ const scanNpmrcForEnvVars = async (storage)=>{
     }
     return envVars;
 };
+/**
+ * Checks if package-lock.json contains file: dependencies (from npm link)
+ * and cleans them up if found by removing package-lock.json and regenerating it.
+ */ const cleanupNpmLinkReferences = async (isDryRun)=>{
+    const logger = getDryRunLogger(isDryRun);
+    const packageLockPath = path__default.join(process.cwd(), 'package-lock.json');
+    try {
+        // Check if package-lock.json exists
+        try {
+            await fs__default.access(packageLockPath);
+        } catch  {
+            // No package-lock.json, nothing to clean
+            logger.verbose('No package-lock.json found, skipping npm link cleanup');
+            return;
+        }
+        // Read and parse package-lock.json
+        const packageLockContent = await fs__default.readFile(packageLockPath, 'utf-8');
+        const packageLock = safeJsonParse(packageLockContent, packageLockPath);
+        // Check for file: dependencies in the lockfile
+        let hasFileReferences = false;
+        // Check in packages (npm v7+)
+        if (packageLock.packages) {
+            for (const [pkgPath, pkgInfo] of Object.entries(packageLock.packages)){
+                if (pkgInfo.resolved && typeof pkgInfo.resolved === 'string' && pkgInfo.resolved.startsWith('file:')) {
+                    // Check if it's a relative path (from npm link) rather than a workspace path
+                    const resolvedPath = pkgInfo.resolved.replace('file:', '');
+                    if (resolvedPath.startsWith('../') || resolvedPath.startsWith('./')) {
+                        hasFileReferences = true;
+                        logger.verbose(`Found npm link reference: ${pkgPath} -> ${pkgInfo.resolved}`);
+                        break;
+                    }
+                }
+            }
+        }
+        // Check in dependencies (npm v6)
+        if (!hasFileReferences && packageLock.dependencies) {
+            for (const [pkgName, pkgInfo] of Object.entries(packageLock.dependencies)){
+                if (pkgInfo.version && typeof pkgInfo.version === 'string' && pkgInfo.version.startsWith('file:')) {
+                    const versionPath = pkgInfo.version.replace('file:', '');
+                    if (versionPath.startsWith('../') || versionPath.startsWith('./')) {
+                        hasFileReferences = true;
+                        logger.verbose(`Found npm link reference: ${pkgName} -> ${pkgInfo.version}`);
+                        break;
+                    }
+                }
+            }
+        }
+        if (hasFileReferences) {
+            logger.info('⚠️  Detected npm link references in package-lock.json');
+            logger.info('🧹 Cleaning up package-lock.json to remove relative file: dependencies...');
+            if (isDryRun) {
+                logger.info('DRY RUN: Would remove package-lock.json and regenerate it');
+            } else {
+                // Remove package-lock.json
+                await fs__default.unlink(packageLockPath);
+                logger.verbose('Removed package-lock.json with npm link references');
+                // Regenerate clean package-lock.json
+                logger.verbose('Regenerating package-lock.json from package.json...');
+                await runWithDryRunSupport('npm install --package-lock-only --no-audit --no-fund', isDryRun);
+                logger.info('✅ Regenerated clean package-lock.json');
+            }
+        } else {
+            logger.verbose('No npm link references found in package-lock.json');
+        }
+    } catch (error) {
+        // Log warning but don't fail - let npm update handle any issues
+        logger.warn(`⚠️  Failed to check/clean npm link references: ${error.message}`);
+        logger.verbose('Continuing with publish process...');
+    }
+};
 const validateEnvironmentVariables = (requiredEnvVars, isDryRun)=>{
     const logger = getDryRunLogger(isDryRun);
     const missingEnvVars = [];
@@ -450,6 +521,9 @@ const execute = async (runConfig)=>{
         logger.info('No open pull request found, starting new release publishing process...');
         // 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.');
+        // Clean up any npm link references before updating dependencies
+        logger.verbose('Checking for npm link references in package-lock.json...');
+        await cleanupNpmLinkReferences(isDryRun);
         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) {
@@ -997,12 +1071,64 @@ const execute = async (runConfig)=>{
     } else {
         logger.verbose('Skipping waiting for release workflows (disabled in config).');
     }
+    // Switch back to source branch and sync with target
     logger.info('');
-    logger.info(`✅ Publish complete!`);
+    logger.info(`🔄 Syncing source branch with target after publish...`);
+    await runWithDryRunSupport(`git checkout ${currentBranch}`, isDryRun);
+    if (!isDryRun) {
+        // Merge target into source (should be fast-forward since PR just merged)
+        logger.info(`Merging ${targetBranch} into ${currentBranch}...`);
+        try {
+            await run(`git merge ${targetBranch} --ff-only`);
+            logger.info(`✅ Merged ${targetBranch} into ${currentBranch}`);
+        } catch (error) {
+            // If ff-only fails, something is wrong - source diverged somehow
+            logger.error(`❌ Failed to fast-forward merge ${targetBranch} into ${currentBranch}`);
+            logger.error('   This suggests the source branch has commits not in target.');
+            logger.error('   This should not happen after a successful PR merge.');
+            logger.warn('⚠️  Attempting regular merge...');
+            await run(`git merge ${targetBranch} --no-edit`);
+        }
+        // Determine version bump based on branch configuration
+        let versionCommand = 'prepatch'; // Default
+        let versionTag = 'dev'; // Default
+        if (branchDependentVersioning && runConfig.branches) {
+            const sourceBranchConfig = runConfig.branches[currentBranch];
+            if (sourceBranchConfig === null || sourceBranchConfig === void 0 ? void 0 : sourceBranchConfig.version) {
+                // Use configured version strategy for source branch
+                if (sourceBranchConfig.version.increment) {
+                    versionCommand = `pre${sourceBranchConfig.version.increment}`;
+                }
+                if (sourceBranchConfig.version.tag) {
+                    versionTag = sourceBranchConfig.version.tag;
+                }
+            }
+        }
+        // Bump to next development version
+        logger.info(`Bumping to next development version...`);
+        try {
+            const { stdout: newVersion } = await run(`npm version ${versionCommand} --preid=${versionTag}`);
+            logger.info(`✅ Version bumped to: ${newVersion.trim()}`);
+        } catch (versionError) {
+            logger.warn(`⚠️  Failed to bump version: ${versionError.message}`);
+            logger.warn('   You may need to manually bump the version for next development cycle.');
+        }
+        // Push updated source branch
+        logger.info(`Pushing updated ${currentBranch} branch...`);
+        try {
+            await run(`git push origin ${currentBranch}`);
+            logger.info(`✅ Pushed ${currentBranch} to origin`);
+        } catch (pushError) {
+            logger.warn(`⚠️  Failed to push ${currentBranch}: ${pushError.message}`);
+            logger.warn(`   Please push manually: git push origin ${currentBranch}`);
+        }
+    } else {
+        logger.info(`Would merge ${targetBranch} into ${currentBranch} with --ff-only`);
+        logger.info(`Would bump version to next development version`);
+        logger.info(`Would push ${currentBranch} to origin`);
+    }
     logger.info('');
-    logger.info(`💡 Next steps:`);
-    logger.info(`   - Run 'kodrdriv development' to return to working branch and bump version`);
-    logger.info(`   - Or manually switch to your working branch to continue development`);
+    logger.info(`✅ Publish complete - on ${currentBranch} with next development version`);
 };
 
 export { execute };