@grunnverk/commands-publish 1.5.1 → 1.5.2

package/dist/index.js

@@ -1,13 +1,16 @@
-import { getDryRunLogger, findDevelopmentBranch, KODRDRIV_DEFAULTS, incrementPatchVersion, incrementMajorVersion, incrementMinorVersion, DEFAULT_TO_COMMIT_ALIAS, Log, DEFAULT_MAX_DIFF_BYTES, Diff, DEFAULT_EXCLUDED_PATTERNS, DEFAULT_OUTPUT_DIRECTORY, toAIConfig, createStorageAdapter, createLoggerAdapter, getOutputPath, getTimestampedResponseFilename, getTimestampedRequestFilename, filterContent, getTimestampedReleaseNotesFilename, improveContentWithLLM, validateReleaseSummary, runGitWithLock, calculateBranchDependentVersion, checkIfTagExists, confirmVersionInteractively, getLogger, ValidationError } from '@grunnverk/core';
-import { getCurrentBranch, run, localBranchExists, safeJsonParse, validatePackageJson, getDefaultFromRef, remoteBranchExists, runSecure, runWithDryRunSupport, validateGitRef, safeSyncBranchWithRemote, isBranchInSyncWithRemote } from '@grunnverk/git-tools';
+import { getDryRunLogger, findDevelopmentBranch, KODRDRIV_DEFAULTS, incrementPatchVersion, incrementMajorVersion, incrementMinorVersion, getLogger, isDevelopmentVersion, DEFAULT_TO_COMMIT_ALIAS, Log, DEFAULT_MAX_DIFF_BYTES, Diff, DEFAULT_EXCLUDED_PATTERNS, DEFAULT_OUTPUT_DIRECTORY, toAIConfig, createStorageAdapter, createLoggerAdapter, getOutputPath, getTimestampedResponseFilename, getTimestampedRequestFilename, filterContent, getTimestampedReleaseNotesFilename, improveContentWithLLM, validateReleaseSummary, runGitWithLock, calculateBranchDependentVersion, checkIfTagExists, confirmVersionInteractively, ValidationError } from '@grunnverk/core';
+import { getCurrentBranch, run, localBranchExists, safeJsonParse, validatePackageJson, getGitStatusSummary, getLinkedDependencies, getDefaultFromRef, remoteBranchExists, runSecure, runWithDryRunSupport, validateGitRef, safeSyncBranchWithRemote, isBranchInSyncWithRemote } from '@grunnverk/git-tools';
 import { createStorage, calculateTargetVersion, incrementPatchVersion as incrementPatchVersion$1 } from '@grunnverk/shared';
-import path from 'path';
+import { scanForPackageJsonFiles } from '@grunnverk/tree-core';
+import * as GitHub from '@grunnverk/github-tools';
+import { getOctokit } from '@grunnverk/github-tools';
+import fs, { readFile } from 'fs/promises';
+import * as path from 'path';
+import path__default from 'path';
 import * as Commit from '@grunnverk/commands-git';
 import { Formatter } from '@riotprompt/riotprompt';
 import 'dotenv/config';
 import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor, createCompletionWithRetry, createReleasePrompt, runAgenticPublish, formatAgenticPublishResult } from '@grunnverk/ai-service';
-import * as GitHub from '@grunnverk/github-tools';
-import fs from 'fs/promises';
 
 /**
  * Create retroactive working branch tags for past releases
@@ -84,7 +87,7 @@ import fs from 'fs/promises';
 }
 /**
  * Execute the development command
- */ const execute$2 = async (runConfig)=>{
+ */ const execute$3 = async (runConfig)=>{
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
     logger.info('DEV_BRANCH_NAVIGATION: Navigating to working branch for development | Purpose: Start development cycle | Next: Version bump and sync');
@@ -340,10 +343,18 @@ import fs from 'fs/promises';
             try {
                 const packageJson = JSON.parse(await fs.readFile('package.json', 'utf-8'));
                 const currentVersion = packageJson.version;
-                // If current version already has the dev tag, we're done
+                // If current version already has the dev tag, check if base version is published
                 if (currentVersion.includes(`-${prereleaseTag}.`)) {
-                    logger.info(`DEV_ALREADY_DEV_VERSION: Already on working branch with development version | Branch: ${workingBranch} | Version: ${currentVersion} | Status: no-bump-needed`);
-                    return 'Already on working branch with development version';
+                    // Check if base version is already published on npm
+                    const baseVersion = currentVersion.split('-')[0];
+                    const { getNpmPublishedVersion } = await import('@grunnverk/core');
+                    const publishedVersion = await getNpmPublishedVersion(packageJson.name);
+                    if (publishedVersion !== baseVersion) {
+                        logger.info(`DEV_ALREADY_DEV_VERSION: Already on working branch with development version | Branch: ${workingBranch} | Version: ${currentVersion} | Status: no-bump-needed`);
+                        return 'Already on working branch with development version';
+                    }
+                    logger.warn(`DEV_VERSION_CONFLICT: Base version already published | Current: ${currentVersion} | Published: ${publishedVersion} | Action: Will bump to next dev version`);
+                // Continue with version bump logic
                 }
             } catch  {
                 logger.debug('Could not check current version, proceeding with version bump');
@@ -518,6 +529,384 @@ import fs from 'fs/promises';
     }
 };
 
+/**
+ * Default patterns for subprojects to exclude from scanning
+ */ const DEFAULT_EXCLUDE_SUBPROJECTS = [
+    'doc/',
+    'docs/',
+    'examples/',
+    'test-*/'
+];
+/**
+ * Execute check-development command
+ */ async function execute$2(config) {
+    var _config_validateReleaseWorkflow;
+    var _config_tree_directories, _config_tree;
+    const logger = getLogger();
+    // Get directory from config - check multiple possible locations
+    const directory = config.directory || ((_config_tree = config.tree) === null || _config_tree === void 0 ? void 0 : (_config_tree_directories = _config_tree.directories) === null || _config_tree_directories === void 0 ? void 0 : _config_tree_directories[0]) || process.cwd();
+    // Get validateRelease flag - controls merge conflicts and open PRs checks
+    const validateRelease = (_config_validateReleaseWorkflow = config.validateReleaseWorkflow) !== null && _config_validateReleaseWorkflow !== void 0 ? _config_validateReleaseWorkflow : false;
+    logger.info(`Checking development readiness in ${directory}${validateRelease ? ' (full release validation)' : ' (quick check)'}`);
+    // Build exclusion patterns
+    const excludedPatterns = [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/.git/**',
+        ...DEFAULT_EXCLUDE_SUBPROJECTS.map((pattern)=>{
+            const normalized = pattern.endsWith('/') ? pattern.slice(0, -1) : pattern;
+            return `**/${normalized}/**`;
+        })
+    ];
+    // Determine if this is a tree or single package
+    const packageJsonFiles = await scanForPackageJsonFiles(directory, excludedPatterns);
+    const isTree = packageJsonFiles.length > 1;
+    logger.info(`Detected ${isTree ? 'tree' : 'single package'} with ${packageJsonFiles.length} package(s)`);
+    const checks = {
+        branch: {
+            passed: true,
+            issues: []
+        },
+        remoteSync: {
+            passed: true,
+            issues: []
+        },
+        mergeConflicts: {
+            passed: true,
+            issues: [],
+            warnings: []
+        },
+        devVersion: {
+            passed: true,
+            issues: []
+        },
+        linkStatus: {
+            passed: true,
+            issues: [],
+            warnings: []
+        },
+        openPRs: {
+            passed: true,
+            issues: [],
+            warnings: []
+        },
+        releaseWorkflow: {
+            passed: true,
+            issues: [],
+            warnings: []
+        }
+    };
+    const packagesToCheck = isTree ? packageJsonFiles : [
+        path.join(directory, 'package.json')
+    ];
+    // Build a set of all local package names for link status checking
+    const localPackageNames = new Set();
+    for (const pkgJsonPath of packagesToCheck){
+        try {
+            const pkgJsonContent = await readFile(pkgJsonPath, 'utf-8');
+            const pkgJson = JSON.parse(pkgJsonContent);
+            if (pkgJson.name) {
+                localPackageNames.add(pkgJson.name);
+            }
+        } catch  {
+        // Skip packages we can't read
+        }
+    }
+    for (const pkgJsonPath of packagesToCheck){
+        var _pkgJson_repository;
+        const pkgDir = path.dirname(pkgJsonPath);
+        const pkgJsonContent = await readFile(pkgJsonPath, 'utf-8');
+        const pkgJson = JSON.parse(pkgJsonContent);
+        const pkgName = pkgJson.name || path.basename(pkgDir);
+        // 1. Check branch status
+        try {
+            const gitStatus = await getGitStatusSummary(pkgDir);
+            if (gitStatus.branch === 'main' || gitStatus.branch === 'master') {
+                checks.branch.passed = false;
+                checks.branch.issues.push(`${pkgName} is on ${gitStatus.branch} branch`);
+            }
+        } catch (error) {
+            checks.branch.issues.push(`${pkgName}: Could not check branch - ${error.message || error}`);
+        }
+        // 2. Check remote sync status
+        try {
+            await run('git fetch', {
+                cwd: pkgDir
+            });
+            const { stdout: statusOutput } = await run('git status -sb', {
+                cwd: pkgDir
+            });
+            if (statusOutput.includes('behind')) {
+                checks.remoteSync.passed = false;
+                const match = statusOutput.match(/behind (\d+)/);
+                const count = match ? match[1] : 'some';
+                checks.remoteSync.issues.push(`${pkgName} is ${count} commits behind remote`);
+            }
+        } catch (error) {
+            checks.remoteSync.issues.push(`${pkgName}: Could not check remote sync - ${error.message || error}`);
+        }
+        // 3. Check for merge conflicts with target branch (main) - ALWAYS CHECK THIS
+        try {
+            const gitStatus = await getGitStatusSummary(pkgDir);
+            const currentBranch = gitStatus.branch;
+            const targetBranch = 'main'; // The branch we'll merge into during publish
+            // Skip if we're already on main
+            if (currentBranch !== 'main' && currentBranch !== 'master') {
+                // Fetch latest to ensure we have up-to-date refs
+                await run('git fetch origin', {
+                    cwd: pkgDir
+                });
+                // Try a test merge to detect conflicts
+                // Use --no-commit --no-ff to simulate the merge without actually doing it
+                try {
+                    // Check if there would be conflicts using git merge --no-commit --no-ff
+                    // This is safer as it doesn't modify the working tree
+                    await run(`git merge --no-commit --no-ff origin/${targetBranch}`, {
+                        cwd: pkgDir
+                    });
+                    // If we get here, check if there are conflicts
+                    const { stdout: statusAfterMerge } = await run('git status --porcelain', {
+                        cwd: pkgDir
+                    });
+                    if (statusAfterMerge.includes('UU ') || statusAfterMerge.includes('AA ') || statusAfterMerge.includes('DD ') || statusAfterMerge.includes('AU ') || statusAfterMerge.includes('UA ') || statusAfterMerge.includes('DU ') || statusAfterMerge.includes('UD ')) {
+                        checks.mergeConflicts.passed = false;
+                        checks.mergeConflicts.issues.push(`${pkgName}: Merge conflicts detected with ${targetBranch} branch`);
+                    }
+                    // Abort the test merge (only if there's actually a merge in progress)
+                    try {
+                        await run('git merge --abort', {
+                            cwd: pkgDir
+                        });
+                    } catch  {
+                    // Ignore - there might not be a merge to abort if it was a fast-forward
+                    }
+                } catch (mergeError) {
+                    var _mergeError_message, _mergeError_stderr;
+                    // Abort any partial merge
+                    try {
+                        await run('git merge --abort', {
+                            cwd: pkgDir
+                        });
+                    } catch  {
+                    // Ignore abort errors
+                    }
+                    // If merge failed, there are likely conflicts
+                    if (((_mergeError_message = mergeError.message) === null || _mergeError_message === void 0 ? void 0 : _mergeError_message.includes('CONFLICT')) || ((_mergeError_stderr = mergeError.stderr) === null || _mergeError_stderr === void 0 ? void 0 : _mergeError_stderr.includes('CONFLICT'))) {
+                        checks.mergeConflicts.passed = false;
+                        checks.mergeConflicts.issues.push(`${pkgName}: Merge conflicts detected with ${targetBranch} branch`);
+                    } else {
+                        // Some other error - log as warning
+                        checks.mergeConflicts.warnings.push(`${pkgName}: Could not check for merge conflicts - ${mergeError.message || mergeError}`);
+                    }
+                }
+            }
+        } catch (error) {
+            checks.mergeConflicts.warnings.push(`${pkgName}: Could not check for merge conflicts - ${error.message || error}`);
+        }
+        // 4. Check dev version status
+        const version = pkgJson.version;
+        if (!version) {
+            checks.devVersion.issues.push(`${pkgName}: No version field in package.json`);
+        } else if (!isDevelopmentVersion(version)) {
+            checks.devVersion.passed = false;
+            checks.devVersion.issues.push(`${pkgName} has non-dev version: ${version}`);
+        } else {
+            // Check if base version exists on npm
+            const baseVersion = version.split('-')[0];
+            try {
+                const { stdout } = await run(`npm view ${pkgName}@${baseVersion} version`, {
+                    cwd: pkgDir
+                });
+                if (stdout.trim() === baseVersion) {
+                    checks.devVersion.passed = false;
+                    checks.devVersion.issues.push(`${pkgName}: Base version ${baseVersion} already published (current: ${version})`);
+                }
+            } catch  {
+            // Version doesn't exist on npm, which is good
+            }
+        }
+        // 5. Check link status (warning only - links are recommended but not required)
+        if (pkgJson.dependencies || pkgJson.devDependencies) {
+            try {
+                const linkedDeps = await getLinkedDependencies(pkgDir);
+                const allDeps = {
+                    ...pkgJson.dependencies,
+                    ...pkgJson.devDependencies
+                };
+                const localDeps = Object.keys(allDeps).filter((dep)=>localPackageNames.has(dep));
+                const unlinkedLocal = localDeps.filter((dep)=>!linkedDeps.has(dep));
+                if (unlinkedLocal.length > 0) {
+                    // Don't fail the check, just warn - links are recommended but not required
+                    checks.linkStatus.warnings.push(`${pkgName}: Local dependencies not linked (recommended): ${unlinkedLocal.join(', ')}`);
+                }
+            } catch (error) {
+                checks.linkStatus.warnings.push(`${pkgName}: Could not check link status - ${error.message || error}`);
+            }
+        }
+        // 6. Check for open PRs from working branch - only if validateRelease is true
+        if (validateRelease && ((_pkgJson_repository = pkgJson.repository) === null || _pkgJson_repository === void 0 ? void 0 : _pkgJson_repository.url)) {
+            try {
+                const gitStatus = await getGitStatusSummary(pkgDir);
+                const currentBranch = gitStatus.branch;
+                // Extract owner/repo from repository URL
+                const repoUrl = pkgJson.repository.url;
+                const match = repoUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+                if (match) {
+                    const [, owner, repo] = match;
+                    try {
+                        const octokit = getOctokit();
+                        const { data: openPRs } = await octokit.pulls.list({
+                            owner,
+                            repo,
+                            state: 'open',
+                            head: `${owner}:${currentBranch}`
+                        });
+                        if (openPRs.length > 0) {
+                            checks.openPRs.passed = false;
+                            for (const pr of openPRs){
+                                const prInfo = `PR #${pr.number}: ${pr.title} (${pr.html_url})`;
+                                checks.openPRs.issues.push(`${pkgName}: ${prInfo}`);
+                            }
+                        }
+                    } catch (prError) {
+                        var _prError_message;
+                        // Only log if it's not a 404 (repo might not exist on GitHub)
+                        if (!((_prError_message = prError.message) === null || _prError_message === void 0 ? void 0 : _prError_message.includes('404')) && (!prError.status || prError.status !== 404)) {
+                            checks.openPRs.warnings.push(`${pkgName}: Could not check PRs - ${prError.message || prError}`);
+                        }
+                    }
+                }
+            } catch (error) {
+                // Don't fail the check if we can't check PRs
+                checks.openPRs.warnings.push(`${pkgName}: Could not check for open PRs - ${error.message || error}`);
+            }
+        }
+        // 7. Check release workflow readiness (validate build, test, publish dry-run)
+        // This check validates that the package can be successfully published
+        // Only run if explicitly requested via config flag
+        if (config.validateReleaseWorkflow) {
+            try {
+                logger.info(`${pkgName}: Validating release workflow readiness...`);
+                // Check 1: Build succeeds
+                try {
+                    await run('npm run build', {
+                        cwd: pkgDir
+                    });
+                    logger.debug(`${pkgName}: Build check passed`);
+                } catch (buildError) {
+                    checks.releaseWorkflow.passed = false;
+                    checks.releaseWorkflow.issues.push(`${pkgName}: Build fails - ${buildError.message || buildError}`);
+                }
+                // Check 2: Tests pass
+                try {
+                    await run('npm test', {
+                        cwd: pkgDir
+                    });
+                    logger.debug(`${pkgName}: Test check passed`);
+                } catch (testError) {
+                    checks.releaseWorkflow.passed = false;
+                    checks.releaseWorkflow.issues.push(`${pkgName}: Tests fail - ${testError.message || testError}`);
+                }
+                // Check 3: Publish dry-run succeeds
+                try {
+                    await run('npm publish --dry-run', {
+                        cwd: pkgDir
+                    });
+                    logger.debug(`${pkgName}: Publish dry-run check passed`);
+                } catch (publishError) {
+                    checks.releaseWorkflow.passed = false;
+                    checks.releaseWorkflow.issues.push(`${pkgName}: Publish dry-run fails - ${publishError.message || publishError}`);
+                }
+                // Check 4: NPM_TOKEN environment variable
+                if (!process.env.NPM_TOKEN) {
+                    checks.releaseWorkflow.warnings.push(`${pkgName}: NPM_TOKEN environment variable not set (required for publishing)`);
+                }
+                // Check 5: GitHub workflow file exists
+                const workflowPath = path.join(pkgDir, '.github', 'workflows', 'npm-publish.yml');
+                try {
+                    await readFile(workflowPath, 'utf-8');
+                    logger.debug(`${pkgName}: GitHub workflow file exists`);
+                } catch  {
+                    checks.releaseWorkflow.warnings.push(`${pkgName}: GitHub workflow file not found at .github/workflows/npm-publish.yml`);
+                }
+            } catch (error) {
+                checks.releaseWorkflow.warnings.push(`${pkgName}: Could not validate release workflow - ${error.message || error}`);
+            }
+        }
+    }
+    // Build summary - linkStatus and releaseWorkflow are not included in allPassed (recommendations)
+    // mergeConflicts is ALWAYS checked (critical for preventing post-merge failures)
+    // openPRs is only checked when validateRelease is true
+    const allPassed = checks.branch.passed && checks.remoteSync.passed && checks.mergeConflicts.passed && checks.devVersion.passed && (validateRelease ? checks.openPRs.passed : true);
+    const hasWarnings = checks.linkStatus.warnings.length > 0 || checks.mergeConflicts.warnings.length > 0 || checks.openPRs.warnings.length > 0 || checks.releaseWorkflow.warnings.length > 0;
+    // Log results
+    let summary = `\n${'='.repeat(60)}\n`;
+    summary += `Development Readiness Check${validateRelease ? ' (Full Release Validation)' : ' (Quick Check)'}\n`;
+    summary += `${'='.repeat(60)}\n\n`;
+    summary += `Type: ${isTree ? 'Tree (monorepo)' : 'Single package'}\n`;
+    summary += `Packages checked: ${packagesToCheck.length}\n\n`;
+    if (allPassed) {
+        summary += `✅ Status: READY FOR DEVELOPMENT\n\n`;
+        summary += `All required checks passed:\n`;
+        summary += `  ✓ Branch status\n`;
+        summary += `  ✓ Remote sync\n`;
+        summary += `  ✓ No merge conflicts with main\n`;
+        summary += `  ✓ Dev versions\n`;
+        if (validateRelease) {
+            summary += `  ✓ No open PRs\n`;
+        }
+        if (!hasWarnings) {
+            summary += `  ✓ All local dependencies linked\n`;
+        }
+    } else {
+        summary += `⚠️  Status: NOT READY\n\n`;
+        if (!checks.branch.passed) {
+            summary += `❌ Branch Issues:\n`;
+            checks.branch.issues.forEach((issue)=>summary += `   - ${issue}\n`);
+            summary += `\n`;
+        }
+        if (!checks.remoteSync.passed) {
+            summary += `❌ Remote Sync Issues:\n`;
+            checks.remoteSync.issues.forEach((issue)=>summary += `   - ${issue}\n`);
+            summary += `\n`;
+        }
+        if (!checks.mergeConflicts.passed) {
+            summary += `❌ Merge Conflict Issues:\n`;
+            checks.mergeConflicts.issues.forEach((issue)=>summary += `   - ${issue}\n`);
+            summary += `\n`;
+        }
+        if (!checks.devVersion.passed) {
+            summary += `❌ Dev Version Issues:\n`;
+            checks.devVersion.issues.forEach((issue)=>summary += `   - ${issue}\n`);
+            summary += `\n`;
+        }
+        if (validateRelease && !checks.openPRs.passed) {
+            summary += `❌ Open PR Issues:\n`;
+            checks.openPRs.issues.forEach((issue)=>summary += `   - ${issue}\n`);
+            summary += `\n`;
+        }
+        if (!checks.releaseWorkflow.passed) {
+            summary += `❌ Release Workflow Issues:\n`;
+            checks.releaseWorkflow.issues.forEach((issue)=>summary += `   - ${issue}\n`);
+            summary += `\n`;
+        }
+    }
+    // Log warnings separately (non-blocking)
+    if (hasWarnings) {
+        summary += `⚠️  Recommendations:\n`;
+        checks.linkStatus.warnings.forEach((warning)=>summary += `   - ${warning}\n`);
+        checks.mergeConflicts.warnings.forEach((warning)=>summary += `   - ${warning}\n`);
+        if (validateRelease) {
+            checks.openPRs.warnings.forEach((warning)=>summary += `   - ${warning}\n`);
+        }
+        checks.releaseWorkflow.warnings.forEach((warning)=>summary += `   - ${warning}\n`);
+        summary += `\n`;
+    }
+    summary += `${'='.repeat(60)}\n`;
+    return summary;
+}
+
 // Helper function to read context files
 async function readContextFiles(contextFiles, logger) {
     if (!contextFiles || contextFiles.length === 0) {
@@ -873,7 +1262,7 @@ const execute$1 = async (runConfig)=>{
 
 const scanNpmrcForEnvVars = async (storage)=>{
     const logger = getLogger();
-    const npmrcPath = path.join(process.cwd(), '.npmrc');
+    const npmrcPath = path__default.join(process.cwd(), '.npmrc');
     const envVars = [];
     if (await storage.exists(npmrcPath)) {
         try {
@@ -903,7 +1292,7 @@ const scanNpmrcForEnvVars = async (storage)=>{
  * development artifacts and sensitive files.
  */ const checkGitignorePatterns = async (storage, isDryRun)=>{
     const logger = getDryRunLogger(isDryRun);
-    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    const gitignorePath = path__default.join(process.cwd(), '.gitignore');
     // Required patterns that must be present in .gitignore
     const requiredPatterns = [
         'node_modules',
@@ -995,7 +1384,7 @@ const scanNpmrcForEnvVars = async (storage)=>{
  * 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.join(process.cwd(), 'package-lock.json');
+    const packageLockPath = path__default.join(process.cwd(), 'package-lock.json');
     try {
         // Check if package-lock.json exists
         try {
@@ -1239,7 +1628,7 @@ const runPrechecks = async (runConfig, targetBranch)=>{
     }
     // Check if prepublishOnly script exists in package.json
     logger.info('PRECHECK_PREPUBLISH: Checking for prepublishOnly script in package.json | Requirement: Must exist to run pre-flight checks | Expected: clean, lint, build, test');
-    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const packageJsonPath = path__default.join(process.cwd(), 'package.json');
     if (!await storage.exists(packageJsonPath)) {
         if (!isDryRun) {
             throw new Error('package.json not found in current directory.');
@@ -1421,6 +1810,63 @@ const execute = async (runConfig)=>{
         currentBranch = 'mock-branch';
     } else {
         currentBranch = await GitHub.getCurrentBranchName();
+    }
+    // Determine target branch EARLY (before expensive operations) for early necessity check
+    let targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
+    let branchDependentVersioning = false;
+    // Check for branches configuration
+    if (runConfig.branches && runConfig.branches[currentBranch]) {
+        branchDependentVersioning = true;
+        const branchConfig = runConfig.branches[currentBranch];
+        if (branchConfig.targetBranch) {
+            targetBranch = branchConfig.targetBranch;
+        }
+        logger.info(`BRANCH_DEPENDENT_TARGETING: Branch-specific configuration active | Source: ${currentBranch} | Target: ${targetBranch} | Feature: Branch-dependent versioning and targeting`);
+        logger.info(`BRANCH_CONFIGURATION_SOURCE: Current branch | Branch: ${currentBranch} | Type: source`);
+        logger.info(`BRANCH_CONFIGURATION_TARGET: Target branch for publish | Branch: ${targetBranch} | Type: destination`);
+        // Look at target branch config to show version strategy
+        const targetBranchConfig = runConfig.branches[targetBranch];
+        if (targetBranchConfig === null || targetBranchConfig === void 0 ? void 0 : targetBranchConfig.version) {
+            const versionType = targetBranchConfig.version.type;
+            const versionTag = targetBranchConfig.version.tag;
+            const versionIncrement = targetBranchConfig.version.increment;
+            logger.info(`VERSION_STRATEGY: Target branch version configuration | Branch: ${targetBranch} | Type: ${versionType} | Tag: ${versionTag || 'none'} | Increment: ${versionIncrement ? 'enabled' : 'disabled'}`);
+        }
+    } else {
+        logger.debug(`BRANCH_TARGETING_DEFAULT: No branch-specific configuration found | Branch: ${currentBranch} | Action: Using default target | Target: ${targetBranch}`);
+    }
+    // Handle --sync-target flag
+    if ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.syncTarget) {
+        await handleTargetBranchSyncRecovery(runConfig, targetBranch);
+        return; // Exit after sync operation
+    }
+    // OPTIMIZATION: Early check if release is necessary BEFORE expensive operations
+    // This can save 2-4 minutes for packages with no changes by skipping:
+    // - git fetch (~30-60s)
+    // - current branch sync (~30-60s)
+    // - target branch setup (~30-60s)
+    // - prechecks (~30-60s)
+    if (!isDryRun) {
+        logger.info('RELEASE_NECESSITY_CHECK_EARLY: Quick check if release is required | Comparison: current branch vs target | Target: ' + targetBranch + ' | Purpose: Skip expensive operations for unchanged packages');
+        try {
+            const necessity = await isReleaseNecessaryComparedToTarget(targetBranch, isDryRun);
+            if (!necessity.necessary) {
+                logger.info(`\nRELEASE_SKIPPED_EARLY: No meaningful changes detected, skipping publish | Reason: ${necessity.reason} | Target: ${targetBranch} | Time saved: ~2-4 minutes`);
+                // Emit a machine-readable marker so tree mode can detect skip and avoid propagating versions
+                // CRITICAL: Use console.log to write to stdout (logger.info goes to stderr via winston)
+                // eslint-disable-next-line no-console
+                console.log('KODRDRIV_PUBLISH_SKIPPED');
+                return;
+            } else {
+                logger.verbose(`RELEASE_PROCEEDING_EARLY: Meaningful changes detected, continuing with full publish workflow | Reason: ${necessity.reason} | Target: ${targetBranch}`);
+            }
+        } catch (error) {
+            // If early check fails (e.g., target branch doesn't exist yet), continue with normal flow
+            logger.verbose(`RELEASE_NECESSITY_CHECK_EARLY_SKIPPED: Unable to perform early check | Error: ${error.message} | Action: Continuing with full workflow | Reason: Target branch may not exist yet or other setup needed`);
+        }
+    }
+    // Now perform expensive operations only if we're proceeding with publish
+    if (!isDryRun) {
         // Fetch latest remote information to avoid conflicts
         logger.info('GIT_FETCH_STARTING: Fetching latest remote information | Remote: origin | Purpose: Avoid conflicts during publish | Command: git fetch origin');
         try {
@@ -1457,35 +1903,6 @@ const execute = async (runConfig)=>{
             }
         }
     }
-    // Determine target branch and version strategy based on branch configuration
-    let targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
-    let branchDependentVersioning = false;
-    // Check for branches configuration
-    if (runConfig.branches && runConfig.branches[currentBranch]) {
-        branchDependentVersioning = true;
-        const branchConfig = runConfig.branches[currentBranch];
-        if (branchConfig.targetBranch) {
-            targetBranch = branchConfig.targetBranch;
-        }
-        logger.info(`BRANCH_DEPENDENT_TARGETING: Branch-specific configuration active | Source: ${currentBranch} | Target: ${targetBranch} | Feature: Branch-dependent versioning and targeting`);
-        logger.info(`BRANCH_CONFIGURATION_SOURCE: Current branch | Branch: ${currentBranch} | Type: source`);
-        logger.info(`BRANCH_CONFIGURATION_TARGET: Target branch for publish | Branch: ${targetBranch} | Type: destination`);
-        // Look at target branch config to show version strategy
-        const targetBranchConfig = runConfig.branches[targetBranch];
-        if (targetBranchConfig === null || targetBranchConfig === void 0 ? void 0 : targetBranchConfig.version) {
-            const versionType = targetBranchConfig.version.type;
-            const versionTag = targetBranchConfig.version.tag;
-            const versionIncrement = targetBranchConfig.version.increment;
-            logger.info(`VERSION_STRATEGY: Target branch version configuration | Branch: ${targetBranch} | Type: ${versionType} | Tag: ${versionTag || 'none'} | Increment: ${versionIncrement ? 'enabled' : 'disabled'}`);
-        }
-    } else {
-        logger.debug(`BRANCH_TARGETING_DEFAULT: No branch-specific configuration found | Branch: ${currentBranch} | Action: Using default target | Target: ${targetBranch}`);
-    }
-    // Handle --sync-target flag
-    if ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.syncTarget) {
-        await handleTargetBranchSyncRecovery(runConfig, targetBranch);
-        return; // Exit after sync operation
-    }
     // Check if target branch exists and create it if needed
     logger.info(`TARGET_BRANCH_CHECK: Verifying target branch existence | Branch: ${targetBranch} | Action: Create if missing | Source: Current HEAD`);
     if (isDryRun) {
@@ -1540,24 +1957,6 @@ const execute = async (runConfig)=>{
     }
     // Run prechecks before starting any work
     await runPrechecks(runConfig, targetBranch);
-    // Early check: determine if a release is necessary compared to target branch
-    logger.info('RELEASE_NECESSITY_CHECK: Evaluating if release is required | Comparison: current branch vs target | Target: ' + targetBranch + ' | Purpose: Avoid unnecessary publishes');
-    try {
-        const necessity = await isReleaseNecessaryComparedToTarget(targetBranch, isDryRun);
-        if (!necessity.necessary) {
-            logger.info(`\nRELEASE_SKIPPED: No meaningful changes detected, skipping publish | Reason: ${necessity.reason} | Target: ${targetBranch}`);
-            // Emit a machine-readable marker so tree mode can detect skip and avoid propagating versions
-            // CRITICAL: Use console.log to write to stdout (logger.info goes to stderr via winston)
-            // eslint-disable-next-line no-console
-            console.log('KODRDRIV_PUBLISH_SKIPPED');
-            return;
-        } else {
-            logger.verbose(`RELEASE_PROCEEDING: Meaningful changes detected, continuing with publish | Reason: ${necessity.reason} | Target: ${targetBranch}`);
-        }
-    } catch (error) {
-        // On unexpected errors, proceed with publish to avoid false negatives blocking releases
-        logger.verbose(`RELEASE_NECESSITY_CHECK_ERROR: Unable to determine release necessity | Error: ${error.message} | Action: Proceeding conservatively with publish | Rationale: Avoid blocking valid releases`);
-    }
     logger.info('RELEASE_PROCESS_STARTING: Initiating release workflow | Target: ' + targetBranch + ' | Phase: dependency updates and version management');
     let pr = null;
     let newVersion = ''; // Will be set during version determination phase
@@ -1788,9 +2187,11 @@ const execute = async (runConfig)=>{
                     logger.info('');
                     if ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.skipAlreadyPublished) {
                         logger.info('PUBLISH_SKIPPED_FLAG: Skipping package due to flag | Flag: --skip-already-published | Version: ' + proposedVersion + ' | Status: skipped');
-                        // Emit skip marker for tree mode detection
+                        // Emit skip marker for tree mode detection with reason
                         // eslint-disable-next-line no-console
                         console.log('KODRDRIV_PUBLISH_SKIPPED');
+                        // eslint-disable-next-line no-console
+                        console.log('KODRDRIV_PUBLISH_SKIP_REASON:already-published');
                         return; // Exit without error
                     } else {
                         throw new Error(`Version ${proposedVersion} already published. Use --skip-already-published to continue.`);
@@ -2568,7 +2969,7 @@ const execute = async (runConfig)=>{
  * Check for required scripts in package.json
  */ async function checkScripts(result, _isDryRun) {
     const storage = createStorage();
-    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const packageJsonPath = path__default.join(process.cwd(), 'package.json');
     try {
         var _packageJson_scripts;
         if (!await storage.exists(packageJsonPath)) {
@@ -2610,7 +3011,7 @@ const execute = async (runConfig)=>{
     if (runConfig.tree) {
         const storage = createStorage();
         const rootPath = process.cwd();
-        const packageJsonPath = path.join(rootPath, 'package.json');
+        const packageJsonPath = path__default.join(rootPath, 'package.json');
         try {
             if (!await storage.exists(packageJsonPath)) {
                 result.errors.push({
@@ -2848,5 +3249,233 @@ const execute = async (runConfig)=>{
     };
 }
 
-export { createDryRunReport, execute$2 as development, logDryRunReport, logTreeDryRunReport, logValidationResults, execute as publish, execute$1 as release, runPreflightValidation, throwIfValidationFailed };
+const logger = getLogger();
+/**
+ * Get the checkpoint file path for a directory
+ */ function getCheckpointPath(workingDirectory) {
+    return path__default.join(workingDirectory, '.kodrdriv-publish-checkpoint.json');
+}
+/**
+ * Save a checkpoint
+ */ async function saveCheckpoint(checkpoint) {
+    const storage = createStorage();
+    const checkpointPath = getCheckpointPath(checkpoint.workingDirectory);
+    try {
+        await storage.writeFile(checkpointPath, JSON.stringify(checkpoint, null, 2), 'utf-8');
+        logger.debug(`CHECKPOINT_SAVED: Saved publish checkpoint | Phase: ${checkpoint.phase} | Package: ${checkpoint.packageName} | Version: ${checkpoint.version}`);
+    } catch (error) {
+        logger.warn(`CHECKPOINT_SAVE_FAILED: Failed to save checkpoint | Error: ${error.message}`);
+    }
+}
+/**
+ * Load the most recent checkpoint
+ */ async function loadCheckpoint(workingDirectory) {
+    const storage = createStorage();
+    const checkpointPath = getCheckpointPath(workingDirectory);
+    try {
+        if (!await storage.exists(checkpointPath)) {
+            return null;
+        }
+        const content = await storage.readFile(checkpointPath, 'utf-8');
+        const checkpoint = JSON.parse(content);
+        logger.debug(`CHECKPOINT_LOADED: Loaded publish checkpoint | Phase: ${checkpoint.phase} | Package: ${checkpoint.packageName} | Version: ${checkpoint.version}`);
+        return checkpoint;
+    } catch (error) {
+        logger.warn(`CHECKPOINT_LOAD_FAILED: Failed to load checkpoint | Error: ${error.message}`);
+        return null;
+    }
+}
+/**
+ * Delete checkpoint (cleanup after successful publish)
+ */ async function deleteCheckpoint(workingDirectory) {
+    const storage = createStorage();
+    const checkpointPath = getCheckpointPath(workingDirectory);
+    try {
+        if (await storage.exists(checkpointPath)) {
+            await storage.deleteFile(checkpointPath);
+            logger.debug('CHECKPOINT_DELETED: Removed publish checkpoint after successful completion');
+        }
+    } catch (error) {
+        logger.warn(`CHECKPOINT_DELETE_FAILED: Failed to delete checkpoint | Error: ${error.message}`);
+    }
+}
+/**
+ * Update an existing checkpoint with new data
+ */ async function updateCheckpoint(workingDirectory, updates) {
+    const existing = await loadCheckpoint(workingDirectory);
+    if (!existing) {
+        logger.warn('CHECKPOINT_UPDATE_FAILED: No existing checkpoint to update');
+        return;
+    }
+    const updated = {
+        ...existing,
+        ...updates,
+        timestamp: new Date().toISOString()
+    };
+    await saveCheckpoint(updated);
+}
+/**
+ * Determine the appropriate recovery strategy based on checkpoint
+ */ function analyzeRecoveryStrategy(checkpoint) {
+    const phase = checkpoint.phase;
+    // Phase: initialized, validated, pr-created
+    // These are safe - nothing permanent has happened yet
+    if (phase === 'initialized' || phase === 'validated' || phase === 'pr-created') {
+        return {
+            recoverable: true,
+            action: 'continue',
+            explanation: 'Publish can be continued or restarted safely',
+            steps: [
+                'Fix any issues that caused the failure',
+                'Run: kodrdriv publish --continue',
+                'Or restart: kodrdriv publish'
+            ],
+            risks: [
+                'None - no permanent changes have been made'
+            ]
+        };
+    }
+    // Phase: pr-merged (but not published)
+    // This is the danger zone - merge is permanent but npm publish hasn't happened
+    if (phase === 'pr-merged' && !checkpoint.npmPublished) {
+        return {
+            recoverable: true,
+            action: 'rollback',
+            explanation: 'PR merged but npm publish failed - can rollback the merge',
+            steps: [
+                'Revert the merge commit on main branch',
+                'Delete any git tags that were created',
+                'Reset working branch to clean state',
+                'Increment version for next attempt',
+                'Run: kodrdriv publish --rollback'
+            ],
+            risks: [
+                'Creates a revert commit in main branch history',
+                'Any work based on the merge will need to be rebased',
+                'Tags will be deleted and recreated on next publish'
+            ]
+        };
+    }
+    // Phase: tagged, npm-publishing (but not completed)
+    // Tags exist but npm publish incomplete
+    if ((phase === 'tagged' || phase === 'npm-publishing') && !checkpoint.npmPublished) {
+        return {
+            recoverable: true,
+            action: 'rollback',
+            explanation: 'Tags created but npm publish incomplete - can rollback',
+            steps: [
+                'Delete git tags',
+                'Revert merge commit if it exists',
+                'Reset working branch',
+                'Increment version',
+                'Run: kodrdriv publish --rollback'
+            ],
+            risks: [
+                'Tags will be deleted and recreated',
+                'Merge commit will be reverted if it exists'
+            ]
+        };
+    }
+    // Phase: npm-published or completed
+    // Package is published - can't rollback npm
+    if (checkpoint.npmPublished || phase === 'npm-published' || phase === 'completed') {
+        return {
+            recoverable: false,
+            action: 'fix-forward',
+            explanation: 'Package already published to npm - must fix forward',
+            steps: [
+                'Package is live on npm - cannot unpublish',
+                'If there are issues, publish a patch version',
+                'Run: kodrdriv publish --target-version patch',
+                'Or manually fix and increment version'
+            ],
+            risks: [
+                'Cannot undo npm publish',
+                'Must publish new version to fix issues'
+            ]
+        };
+    }
+    // Phase: failed (generic failure)
+    if (phase === 'failed') {
+        // Determine based on what was completed
+        if (checkpoint.npmPublished) {
+            return analyzeRecoveryStrategy({
+                ...checkpoint,
+                phase: 'npm-published'
+            });
+        } else if (checkpoint.prNumber) {
+            return analyzeRecoveryStrategy({
+                ...checkpoint,
+                phase: 'pr-merged'
+            });
+        } else {
+            return analyzeRecoveryStrategy({
+                ...checkpoint,
+                phase: 'initialized'
+            });
+        }
+    }
+    // Unknown phase or state
+    return {
+        recoverable: false,
+        action: 'none',
+        explanation: 'Unable to determine recovery strategy from checkpoint',
+        steps: [
+            'Manually inspect the repository state',
+            'Check: git status, git log, npm view <package>',
+            'Determine what was completed',
+            'Contact support if needed'
+        ],
+        risks: [
+            'Manual intervention required'
+        ]
+    };
+}
+/**
+ * Get a human-readable summary of the checkpoint
+ */ function getCheckpointSummary(checkpoint) {
+    const lines = [];
+    lines.push('='.repeat(60));
+    lines.push('Publish Checkpoint Summary');
+    lines.push('='.repeat(60));
+    lines.push('');
+    lines.push(`Package: ${checkpoint.packageName}`);
+    lines.push(`Version: ${checkpoint.version}`);
+    lines.push(`Phase: ${checkpoint.phase}`);
+    lines.push(`Branch: ${checkpoint.branch}`);
+    lines.push(`Timestamp: ${checkpoint.timestamp}`);
+    lines.push('');
+    if (checkpoint.prNumber) {
+        lines.push(`Pull Request: #${checkpoint.prNumber}`);
+        if (checkpoint.prUrl) {
+            lines.push(`PR URL: ${checkpoint.prUrl}`);
+        }
+    }
+    if (checkpoint.tags.length > 0) {
+        lines.push(`Tags Created: ${checkpoint.tags.join(', ')}`);
+    }
+    if (checkpoint.npmPublished) {
+        lines.push('✅ npm Published: Yes');
+    } else {
+        lines.push('❌ npm Published: No');
+    }
+    if (checkpoint.workflowRunUrl) {
+        lines.push(`Workflow: ${checkpoint.workflowRunUrl}`);
+    }
+    if (checkpoint.error) {
+        lines.push('');
+        lines.push('Error:');
+        lines.push(`  ${checkpoint.error}`);
+    }
+    lines.push('');
+    lines.push('='.repeat(60));
+    return lines.join('\n');
+}
+/**
+ * Check if a checkpoint indicates a failed publish
+ */ function isFailedPublish(checkpoint) {
+    return checkpoint.phase === 'failed' || checkpoint.phase === 'pr-merged' && !checkpoint.npmPublished || checkpoint.phase === 'tagged' && !checkpoint.npmPublished || checkpoint.phase === 'npm-publishing' && !checkpoint.npmPublished;
+}
+
+export { analyzeRecoveryStrategy, execute$2 as checkDevelopment, createDryRunReport, deleteCheckpoint, execute$3 as development, getCheckpointSummary, isFailedPublish, loadCheckpoint, logDryRunReport, logTreeDryRunReport, logValidationResults, execute as publish, execute$1 as release, runPreflightValidation, saveCheckpoint, throwIfValidationFailed, updateCheckpoint };
 //# sourceMappingURL=index.js.map