@eldrforge/commands-tree 0.1.0

package/dist/branchState-CtywDSJf.js

@@ -0,0 +1,699 @@
+import { run } from '@eldrforge/git-tools';
+import { getLogger, getGitRepositoryRoot, isInGitRepository } from '@eldrforge/core';
+
+/**
+ * Check the branch status for a package
+ */ async function checkBranchStatus(packagePath, expectedBranch, targetBranch = 'main', checkPR = false, options = {}) {
+    const logger = getLogger();
+    // Check if path is in a git repository
+    if (!isInGitRepository(packagePath)) {
+        logger.debug(`Path is not in a git repository: ${packagePath}. Skipping branch status check.`);
+        return {
+            name: 'non-git',
+            isOnExpectedBranch: true,
+            ahead: 0,
+            behind: 0,
+            hasUnpushedCommits: false,
+            needsSync: false,
+            remoteExists: false
+        };
+    }
+    try {
+        // Get current branch
+        const { stdout: currentBranch } = await run('git rev-parse --abbrev-ref HEAD', {
+            cwd: packagePath,
+            suppressErrorLogging: true
+        });
+        const branch = currentBranch.trim();
+        // Check if remote exists
+        let remoteExists = false;
+        try {
+            await run(`git ls-remote --exit-code --heads origin ${branch}`, {
+                cwd: packagePath,
+                suppressErrorLogging: true
+            });
+            remoteExists = true;
+        } catch  {
+            remoteExists = false;
+        }
+        // Get ahead/behind counts if remote exists
+        let ahead = 0;
+        let behind = 0;
+        if (remoteExists) {
+            try {
+                const { stdout: revList } = await run(`git rev-list --left-right --count origin/${branch}...HEAD`, {
+                    cwd: packagePath,
+                    suppressErrorLogging: true
+                });
+                const [behindStr, aheadStr] = revList.trim().split('\t');
+                behind = parseInt(behindStr, 10) || 0;
+                ahead = parseInt(aheadStr, 10) || 0;
+            } catch (error) {
+                logger.verbose(`Could not get ahead/behind counts for ${packagePath}: ${error}`);
+            }
+        }
+        // Check for merge conflicts with target branch
+        let hasMergeConflicts = false;
+        let conflictsWith;
+        if (branch !== targetBranch) {
+            try {
+                // Fetch latest to ensure we're checking against current target
+                if (!options.skipFetch) {
+                    logger.verbose(`    Fetching latest from origin for ${packagePath}...`);
+                    await run('git fetch origin --quiet', {
+                        cwd: packagePath,
+                        suppressErrorLogging: true
+                    });
+                }
+                logger.verbose(`    Checking for merge conflicts with ${targetBranch}...`);
+                // Use git merge-tree to test for conflicts without actually merging
+                const { stdout: mergeTree } = await run(`git merge-tree $(git merge-base ${branch} origin/${targetBranch}) ${branch} origin/${targetBranch}`, {
+                    cwd: packagePath,
+                    suppressErrorLogging: true
+                });
+                // If merge-tree output contains conflict markers, there are conflicts
+                if (mergeTree.includes('<<<<<<<') || mergeTree.includes('=======') || mergeTree.includes('>>>>>>>')) {
+                    hasMergeConflicts = true;
+                    conflictsWith = targetBranch;
+                    logger.verbose(`    ⚠️  Merge conflicts detected with ${targetBranch}`);
+                }
+            } catch (error) {
+                // If merge-tree fails, might be due to git version or other issues
+                logger.verbose(`Could not check merge conflicts for ${packagePath}: ${error.message}`);
+            }
+        }
+        // Check for existing PR if requested
+        let hasOpenPR = false;
+        let prUrl;
+        let prNumber;
+        if (checkPR) {
+            try {
+                logger.verbose(`    Checking GitHub for existing PRs...`);
+                const { findOpenPullRequestByHeadRef } = await import('./index-DqPh_i40.js');
+                const pr = await findOpenPullRequestByHeadRef(branch, packagePath);
+                if (pr) {
+                    hasOpenPR = true;
+                    prUrl = pr.html_url;
+                    prNumber = pr.number;
+                    logger.verbose(`    Found existing PR #${prNumber}: ${prUrl}`);
+                }
+            } catch (error) {
+                logger.verbose(`Could not check for PR for ${packagePath}: ${error.message}`);
+            }
+        }
+        const isOnExpectedBranch = !expectedBranch || branch === expectedBranch;
+        const hasUnpushedCommits = ahead > 0;
+        const needsSync = behind > 0;
+        return {
+            name: branch,
+            isOnExpectedBranch,
+            expectedBranch,
+            ahead,
+            behind,
+            hasUnpushedCommits,
+            needsSync,
+            remoteExists,
+            hasMergeConflicts,
+            conflictsWith,
+            hasOpenPR,
+            prUrl,
+            prNumber
+        };
+    } catch (error) {
+        logger.error(`Error checking branch status for ${packagePath}: ${error.message}`);
+        return {
+            name: 'unknown',
+            isOnExpectedBranch: false,
+            ahead: 0,
+            behind: 0,
+            hasUnpushedCommits: false,
+            needsSync: false,
+            remoteExists: false
+        };
+    }
+}
+/**
+ * Check if target branch (e.g., main) is exactly in sync with remote
+ */ async function checkTargetBranchSync(packagePath, targetBranch = 'main', options = {}) {
+    const logger = getLogger();
+    // Check if path is in a git repository
+    if (!isInGitRepository(packagePath)) {
+        return {
+            targetBranch,
+            localExists: false,
+            remoteExists: false,
+            exactMatch: true,
+            canFastForward: false,
+            needsReset: false
+        };
+    }
+    try {
+        // Fetch latest from origin to ensure we have current info
+        if (!options.skipFetch) {
+            try {
+                await run('git fetch origin --quiet', {
+                    cwd: packagePath,
+                    suppressErrorLogging: true
+                });
+            } catch (error) {
+                logger.verbose(`Could not fetch from origin in ${packagePath}: ${error.message}`);
+            }
+        }
+        // Check if local target branch exists
+        let localExists = false;
+        let localSha;
+        try {
+            const { stdout } = await run(`git rev-parse --verify ${targetBranch}`, {
+                cwd: packagePath,
+                suppressErrorLogging: true
+            });
+            localSha = stdout.trim();
+            localExists = true;
+        } catch  {
+            localExists = false;
+        }
+        // Check if remote target branch exists
+        let remoteExists = false;
+        let remoteSha;
+        try {
+            const { stdout } = await run(`git ls-remote origin ${targetBranch}`, {
+                cwd: packagePath,
+                suppressErrorLogging: true
+            });
+            if (stdout.trim()) {
+                remoteSha = stdout.split(/\s+/)[0];
+                remoteExists = true;
+            }
+        } catch  {
+            remoteExists = false;
+        }
+        // Determine sync status
+        const exactMatch = localExists && remoteExists && localSha === remoteSha;
+        let canFastForward = false;
+        let needsReset = false;
+        if (localExists && remoteExists && !exactMatch) {
+            // Check if local is ancestor of remote (can fast-forward)
+            try {
+                await run(`git merge-base --is-ancestor ${targetBranch} origin/${targetBranch}`, {
+                    cwd: packagePath,
+                    suppressErrorLogging: true
+                });
+                canFastForward = true;
+                needsReset = false;
+            } catch  {
+                // Local is not ancestor of remote, need reset
+                canFastForward = false;
+                needsReset = true;
+            }
+        }
+        return {
+            targetBranch,
+            localExists,
+            remoteExists,
+            localSha,
+            remoteSha,
+            exactMatch,
+            canFastForward,
+            needsReset
+        };
+    } catch (error) {
+        return {
+            targetBranch,
+            localExists: false,
+            remoteExists: false,
+            exactMatch: false,
+            canFastForward: false,
+            needsReset: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * Audit branch state across multiple packages
+ */ async function auditBranchState(packages, expectedBranch, options = {}) {
+    const logger = getLogger();
+    const targetBranch = options.targetBranch || 'main';
+    const checkPR = options.checkPR !== false; // Default true
+    const checkConflicts = options.checkConflicts !== false; // Default true
+    const checkVersions = options.checkVersions !== false; // Default true
+    const concurrency = options.concurrency || 5;
+    logger.info(`BRANCH_STATE_AUDIT: Auditing branch state for packages | Package Count: ${packages.length} | Concurrency: ${concurrency} | Purpose: Verify synchronization`);
+    // Helper for concurrency-limited parallel map
+    const parallelMap = async (items, fn)=>{
+        const results = new Array(items.length);
+        const queue = items.map((item, index)=>({
+                item,
+                index
+            }));
+        let nextIndex = 0;
+        const workers = Array(Math.min(concurrency, items.length)).fill(null).map(async ()=>{
+            while(nextIndex < queue.length){
+                const task = queue[nextIndex++];
+                results[task.index] = await fn(task.item, task.index);
+            }
+        });
+        await Promise.all(workers);
+        return results;
+    };
+    // If no expected branch specified, find the most common branch
+    let actualExpectedBranch = expectedBranch;
+    if (!expectedBranch) {
+        logger.info('📋 Phase 1/3: Detecting most common branch across packages (optimized)...');
+        const branchNames = await parallelMap(packages, async (pkg)=>{
+            if (!isInGitRepository(pkg.path)) {
+                return 'non-git';
+            }
+            try {
+                const { stdout } = await run('git rev-parse --abbrev-ref HEAD', {
+                    cwd: pkg.path,
+                    suppressErrorLogging: true
+                });
+                return stdout.trim();
+            } catch  {
+                return 'unknown';
+            }
+        });
+        const branchCounts = new Map();
+        for (const name of branchNames){
+            branchCounts.set(name, (branchCounts.get(name) || 0) + 1);
+        }
+        // Find most common branch
+        let maxCount = 0;
+        for (const [branch, count] of branchCounts.entries()){
+            if (count > maxCount && branch !== 'unknown' && branch !== 'non-git') {
+                maxCount = count;
+                actualExpectedBranch = branch;
+            }
+        }
+        if (!actualExpectedBranch) actualExpectedBranch = 'main';
+        logger.info(`✓ Most common branch: ${actualExpectedBranch} (${maxCount}/${packages.length} packages)`);
+    }
+    // Phase 2: Identify unique repos and fetch once per repo
+    logger.info(`\n📋 Phase 2/3: Fetching latest from remotes (one fetch per repository)...`);
+    const repoRoots = new Set();
+    for (const pkg of packages){
+        const root = getGitRepositoryRoot(pkg.path);
+        if (root) repoRoots.add(root);
+    }
+    const repoList = Array.from(repoRoots);
+    await parallelMap(repoList, async (repo, i)=>{
+        try {
+            logger.verbose(`  [${i + 1}/${repoList.length}] Fetching in: ${repo}`);
+            await run('git fetch origin --quiet', {
+                cwd: repo,
+                suppressErrorLogging: true
+            });
+        } catch (error) {
+            logger.debug(`Could not fetch in ${repo}: ${error.message}`);
+        }
+    });
+    logger.info(`✓ Fetched latest information for ${repoList.length} unique repositories`);
+    // Phase 3: Full audit in parallel
+    logger.info(`\n📋 Phase 3/3: Auditing package state (git status, conflicts, PRs, versions)...`);
+    let completedCount = 0;
+    const audits = await parallelMap(packages, async (pkg)=>{
+        // Check target branch sync (e.g., is local main exactly in sync with remote main?)
+        const targetBranchSync = await checkTargetBranchSync(pkg.path, targetBranch, {
+            skipFetch: true
+        });
+        const status = await checkBranchStatus(pkg.path, actualExpectedBranch, targetBranch, checkPR, {
+            skipFetch: true
+        });
+        const issues = [];
+        const fixes = [];
+        let versionStatus;
+        // Skip issues for non-git repositories
+        if (status.name === 'non-git') {
+            completedCount++;
+            if (completedCount % 5 === 0 || completedCount === packages.length) {
+                logger.info(`  Progress: ${completedCount}/${packages.length} packages audited`);
+            }
+            return {
+                packageName: pkg.name,
+                path: pkg.path,
+                status,
+                versionStatus,
+                targetBranchSync,
+                issues,
+                fixes
+            };
+        }
+        // Check for issues
+        if (!status.isOnExpectedBranch && actualExpectedBranch) {
+            issues.push(`On branch '${status.name}' (most packages are on '${actualExpectedBranch}')`);
+            fixes.push(`cd ${pkg.path} && git checkout ${actualExpectedBranch}`);
+        }
+        if (checkConflicts && status.hasMergeConflicts && status.conflictsWith) {
+            issues.push(`⚠️  MERGE CONFLICTS with '${status.conflictsWith}'`);
+            fixes.push(`cd ${pkg.path} && git merge origin/${status.conflictsWith}  # Resolve conflicts manually`);
+        }
+        if (checkPR && status.hasOpenPR) {
+            issues.push(`Has existing PR #${status.prNumber}: ${status.prUrl}`);
+            fixes.push(`# Review PR: ${status.prUrl}`);
+        }
+        if (status.hasUnpushedCommits) {
+            issues.push(`Ahead of remote by ${status.ahead} commit(s)`);
+            fixes.push(`cd ${pkg.path} && git push origin ${status.name}`);
+        }
+        if (status.needsSync) {
+            issues.push(`Behind remote by ${status.behind} commit(s)`);
+            fixes.push(`cd ${pkg.path} && git pull origin ${status.name}`);
+        }
+        if (!status.remoteExists) {
+            issues.push(`Remote branch does not exist`);
+            fixes.push(`cd ${pkg.path} && git push -u origin ${status.name}`);
+        }
+        // Check version consistency if enabled
+        if (checkVersions) {
+            try {
+                const { validateVersionForBranch } = await import('@eldrforge/core');
+                const fs = await import('fs/promises');
+                const pathModule = await import('path');
+                const packageJsonPath = pathModule.join(pkg.path, 'package.json');
+                const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+                const packageJson = JSON.parse(packageJsonContent);
+                const version = packageJson.version;
+                const validation = validateVersionForBranch(version, status.name);
+                versionStatus = {
+                    version,
+                    isValid: validation.valid,
+                    issue: validation.issue,
+                    fix: validation.fix
+                };
+                if (!validation.valid) {
+                    issues.push(`Version: ${version} - ${validation.issue}`);
+                    fixes.push(`cd ${pkg.path} && kodrdriv development  # ${validation.fix}`);
+                }
+            } catch (error) {
+                logger.verbose(`Could not check version for ${pkg.name}: ${error.message}`);
+            }
+        }
+        // Check target branch sync (e.g., is local main exactly in sync with remote main?)
+        if (targetBranchSync.localExists && targetBranchSync.remoteExists && !targetBranchSync.exactMatch) {
+            if (targetBranchSync.needsReset) {
+                issues.push(`Target branch '${targetBranch}' is NOT in sync with remote (local has diverged)`);
+                fixes.push(`cd ${pkg.path} && git checkout ${targetBranch} && git reset --hard origin/${targetBranch} && git checkout ${status.name}`);
+            } else if (targetBranchSync.canFastForward) {
+                issues.push(`Target branch '${targetBranch}' is behind remote (can fast-forward)`);
+                fixes.push(`cd ${pkg.path} && git checkout ${targetBranch} && git pull origin ${targetBranch} && git checkout ${status.name}`);
+            } else {
+                issues.push(`Target branch '${targetBranch}' is NOT in exact sync with remote`);
+                fixes.push(`cd ${pkg.path} && git checkout ${targetBranch} && git pull origin ${targetBranch} && git checkout ${status.name}`);
+            }
+        } else if (!targetBranchSync.localExists && targetBranchSync.remoteExists) {
+            // Local target branch doesn't exist but exists on remote
+            issues.push(`Target branch '${targetBranch}' does not exist locally (exists on remote)`);
+            fixes.push(`cd ${pkg.path} && git branch ${targetBranch} origin/${targetBranch}`);
+        } else if (targetBranchSync.error) {
+            logger.verbose(`Could not check target branch sync for ${pkg.name}: ${targetBranchSync.error}`);
+        }
+        completedCount++;
+        if (completedCount % 5 === 0 || completedCount === packages.length) {
+            logger.info(`  Progress: ${completedCount}/${packages.length} packages audited`);
+        }
+        return {
+            packageName: pkg.name,
+            path: pkg.path,
+            status,
+            versionStatus,
+            targetBranchSync,
+            issues,
+            fixes
+        };
+    });
+    const issuesFound = audits.filter((a)=>a.issues.length > 0).length;
+    const versionIssues = audits.filter((a)=>a.versionStatus && !a.versionStatus.isValid).length;
+    const targetBranchSyncIssues = audits.filter((a)=>a.targetBranchSync && !a.targetBranchSync.exactMatch && a.targetBranchSync.localExists && a.targetBranchSync.remoteExists).length;
+    const goodPackages = audits.filter((a)=>a.issues.length === 0).length;
+    logger.info(`✓ Audit complete: ${goodPackages}/${packages.length} packages have no issues`);
+    if (issuesFound > 0) {
+        logger.info(`  Issues found in ${issuesFound} package(s)`);
+    }
+    return {
+        totalPackages: packages.length,
+        goodPackages,
+        issuesFound,
+        versionIssues,
+        targetBranchSyncIssues,
+        audits
+    };
+}
+/**
+ * Format audit results for display with detailed fix instructions
+ */ function formatAuditResults(result) {
+    const lines = [];
+    // Determine the common branch if any
+    const branchCounts = new Map();
+    for (const audit of result.audits){
+        const branch = audit.status.name;
+        branchCounts.set(branch, (branchCounts.get(branch) || 0) + 1);
+    }
+    let commonBranch;
+    let maxCount = 0;
+    for (const [branch, count] of branchCounts.entries()){
+        if (count > maxCount) {
+            maxCount = count;
+            commonBranch = branch;
+        }
+    }
+    lines.push('╔══════════════════════════════════════════════════════════════╗');
+    lines.push(`║  Branch State Audit (${result.totalPackages} packages)`.padEnd(63) + '║');
+    if (commonBranch && maxCount === result.totalPackages) {
+        lines.push(`║  All packages on: ${commonBranch}`.padEnd(63) + '║');
+    } else if (commonBranch) {
+        lines.push(`║  Most packages on: ${commonBranch} (${maxCount}/${result.totalPackages})`.padEnd(63) + '║');
+    }
+    lines.push('╠══════════════════════════════════════════════════════════════╣');
+    lines.push('');
+    if (result.goodPackages > 0) {
+        lines.push(`✅ Good State (${result.goodPackages} package${result.goodPackages === 1 ? '' : 's'}):`);
+        const goodAudits = result.audits.filter((a)=>a.issues.length === 0);
+        const displayCount = Math.min(goodAudits.length, 5);
+        goodAudits.slice(0, displayCount).forEach((audit)=>{
+            const versionInfo = audit.versionStatus ? ` (v${audit.versionStatus.version})` : '';
+            lines.push(`   ${audit.packageName}${versionInfo}`);
+        });
+        if (goodAudits.length > displayCount) {
+            lines.push(`   ... and ${goodAudits.length - displayCount} more`);
+        }
+        lines.push('');
+    }
+    // Show version issues prominently if any
+    if (result.versionIssues > 0) {
+        lines.push(`⚠️  Version Issues (${result.versionIssues} package${result.versionIssues === 1 ? '' : 's'}):`);
+        const versionIssueAudits = result.audits.filter((a)=>a.versionStatus && !a.versionStatus.isValid);
+        versionIssueAudits.forEach((audit)=>{
+            lines.push(`   ${audit.packageName}`);
+            lines.push(`   - Branch: ${audit.status.name}`);
+            lines.push(`   - Version: ${audit.versionStatus.version}`);
+            lines.push(`   - Issue: ${audit.versionStatus.issue}`);
+            lines.push(`   - Fix: ${audit.versionStatus.fix}`);
+            lines.push('');
+        });
+    }
+    // Show target branch sync issues prominently if any
+    if (result.targetBranchSyncIssues > 0) {
+        lines.push(`🚨 Target Branch Sync Issues (${result.targetBranchSyncIssues} package${result.targetBranchSyncIssues === 1 ? '' : 's'}):`);
+        lines.push(`   ⚠️  ${result.targetBranchSyncIssues} package${result.targetBranchSyncIssues === 1 ? '' : 's'} with target branch NOT in sync with remote`);
+        lines.push(`   This will cause "branch out of sync" errors during parallel publish!`);
+        lines.push('');
+        const targetSyncIssueAudits = result.audits.filter((a)=>a.targetBranchSync && !a.targetBranchSync.exactMatch && a.targetBranchSync.localExists && a.targetBranchSync.remoteExists);
+        targetSyncIssueAudits.forEach((audit)=>{
+            var _sync_localSha, _sync_remoteSha;
+            const sync = audit.targetBranchSync;
+            lines.push(`   ${audit.packageName}`);
+            lines.push(`   - Target Branch: ${sync.targetBranch}`);
+            lines.push(`   - Local SHA:  ${(_sync_localSha = sync.localSha) === null || _sync_localSha === void 0 ? void 0 : _sync_localSha.substring(0, 8)}...`);
+            lines.push(`   - Remote SHA: ${(_sync_remoteSha = sync.remoteSha) === null || _sync_remoteSha === void 0 ? void 0 : _sync_remoteSha.substring(0, 8)}...`);
+            if (sync.needsReset) {
+                lines.push(`   - Action: RESET REQUIRED (local has diverged)`);
+            } else if (sync.canFastForward) {
+                lines.push(`   - Action: Pull to fast-forward`);
+            }
+            lines.push('');
+        });
+    }
+    if (result.issuesFound > 0) {
+        // Count critical issues (merge conflicts, existing PRs, target branch sync)
+        const conflictCount = result.audits.filter((a)=>a.status.hasMergeConflicts).length;
+        const prCount = result.audits.filter((a)=>a.status.hasOpenPR).length;
+        const branchInconsistentCount = result.audits.filter((a)=>!a.status.isOnExpectedBranch).length;
+        const unpushedCount = result.audits.filter((a)=>a.status.hasUnpushedCommits).length;
+        const behindCount = result.audits.filter((a)=>a.status.needsSync).length;
+        const noRemoteCount = result.audits.filter((a)=>!a.status.remoteExists).length;
+        if (conflictCount > 0 || prCount > 0 || result.targetBranchSyncIssues > 0) {
+            lines.push(`🚨 CRITICAL ISSUES:`);
+            if (result.targetBranchSyncIssues > 0) {
+                lines.push(`   🔄 ${result.targetBranchSyncIssues} package${result.targetBranchSyncIssues === 1 ? '' : 's'} with target branch sync issues`);
+            }
+            if (conflictCount > 0) {
+                lines.push(`   ⚠️  ${conflictCount} package${conflictCount === 1 ? '' : 's'} with merge conflicts`);
+            }
+            if (prCount > 0) {
+                lines.push(`   📋 ${prCount} package${prCount === 1 ? '' : 's'} with existing PRs`);
+            }
+            lines.push('');
+        }
+        lines.push(`⚠️  Issues Summary:`);
+        if (result.targetBranchSyncIssues > 0) lines.push(`   • ${result.targetBranchSyncIssues} target branch sync issue${result.targetBranchSyncIssues === 1 ? '' : 's'}`);
+        if (conflictCount > 0) lines.push(`   • ${conflictCount} merge conflict${conflictCount === 1 ? '' : 's'}`);
+        if (prCount > 0) lines.push(`   • ${prCount} existing PR${prCount === 1 ? '' : 's'}`);
+        if (branchInconsistentCount > 0) lines.push(`   • ${branchInconsistentCount} branch inconsistenc${branchInconsistentCount === 1 ? 'y' : 'ies'}`);
+        if (unpushedCount > 0) lines.push(`   • ${unpushedCount} package${unpushedCount === 1 ? '' : 's'} with unpushed commits`);
+        if (behindCount > 0) lines.push(`   • ${behindCount} package${behindCount === 1 ? '' : 's'} behind remote`);
+        if (noRemoteCount > 0) lines.push(`   • ${noRemoteCount} package${noRemoteCount === 1 ? '' : 's'} with no remote branch`);
+        lines.push('');
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('📋 DETAILED ISSUES AND FIXES:');
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('');
+        // Sort issues by severity: conflicts first, then PRs, then others
+        const auditsWithIssues = result.audits.filter((a)=>a.issues.length > 0);
+        const sortedAudits = auditsWithIssues.sort((a, b)=>{
+            const aScore = (a.status.hasMergeConflicts ? 1000 : 0) + (a.status.hasOpenPR ? 100 : 0);
+            const bScore = (b.status.hasMergeConflicts ? 1000 : 0) + (b.status.hasOpenPR ? 100 : 0);
+            return bScore - aScore;
+        });
+        sortedAudits.forEach((audit, index)=>{
+            // Highlight critical issues
+            const hasCritical = audit.status.hasMergeConflicts || audit.status.hasOpenPR;
+            const prefix = hasCritical ? '🚨 CRITICAL' : '⚠️  WARNING';
+            lines.push(`${prefix} [${index + 1}/${sortedAudits.length}] ${audit.packageName}`);
+            lines.push(`Location: ${audit.path}`);
+            lines.push(`Branch: ${audit.status.name}`);
+            if (audit.status.remoteExists) {
+                const syncStatus = [];
+                if (audit.status.ahead > 0) syncStatus.push(`ahead ${audit.status.ahead}`);
+                if (audit.status.behind > 0) syncStatus.push(`behind ${audit.status.behind}`);
+                if (syncStatus.length > 0) {
+                    lines.push(`Sync: ${syncStatus.join(', ')}`);
+                }
+            } else {
+                lines.push(`Remote: Does not exist`);
+            }
+            lines.push('');
+            lines.push('Issues:');
+            audit.issues.forEach((issue)=>{
+                const icon = issue.includes('MERGE CONFLICTS') ? '⚠️ ' : issue.includes('PR') ? '📋 ' : '❌ ';
+                lines.push(`  ${icon} ${issue}`);
+            });
+            lines.push('');
+            lines.push('Fix Commands (execute in order):');
+            audit.fixes.forEach((fix, fixIndex)=>{
+                lines.push(`  ${fixIndex + 1}. ${fix}`);
+            });
+            // Add context-specific guidance
+            if (audit.status.hasMergeConflicts) {
+                lines.push('');
+                lines.push('  ⚠️  Merge Conflict Resolution:');
+                lines.push('     After running the merge command above, you will need to:');
+                lines.push('     a) Manually edit conflicting files to resolve conflicts');
+                lines.push('     b) Stage resolved files: git add <file>');
+                lines.push('     c) Complete the merge: git commit');
+                lines.push('     d) Push the resolved merge: git push origin ' + audit.status.name);
+                lines.push('     e) Re-run audit to verify: kodrdriv tree publish --audit-branches');
+            }
+            if (audit.status.hasOpenPR) {
+                lines.push('');
+                lines.push('  📋 Existing PR Handling:');
+                lines.push('     You have options:');
+                lines.push('     a) Continue with existing PR (kodrdriv publish will detect and use it)');
+                lines.push('     b) Close the PR if no longer needed');
+                lines.push('     c) Merge the PR if ready, then create new one');
+            }
+            lines.push('');
+            lines.push('─────────────────────────────────────────────────────────────');
+            lines.push('');
+        });
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('📝 RECOMMENDED WORKFLOW:');
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('');
+        let stepNumber = 1;
+        // Target branch sync is FIRST and most critical
+        if (result.targetBranchSyncIssues > 0) {
+            lines.push(`${stepNumber}️⃣  SYNC TARGET BRANCHES (CRITICAL - Do this FIRST):`);
+            stepNumber++;
+            const targetSyncIssueAudits = result.audits.filter((a)=>a.targetBranchSync && !a.targetBranchSync.exactMatch && a.targetBranchSync.localExists && a.targetBranchSync.remoteExists);
+            targetSyncIssueAudits.forEach((audit)=>{
+                const sync = audit.targetBranchSync;
+                if (sync.needsReset) {
+                    lines.push(`   • ${audit.packageName}: cd ${audit.path} && git checkout ${sync.targetBranch} && git reset --hard origin/${sync.targetBranch} && git checkout ${audit.status.name}`);
+                } else {
+                    lines.push(`   • ${audit.packageName}: cd ${audit.path} && git checkout ${sync.targetBranch} && git pull origin ${sync.targetBranch} && git checkout ${audit.status.name}`);
+                }
+            });
+            lines.push('');
+        }
+        if (conflictCount > 0) {
+            lines.push(`${stepNumber}️⃣  RESOLVE MERGE CONFLICTS FIRST (blocking):`);
+            stepNumber++;
+            sortedAudits.filter((a)=>a.status.hasMergeConflicts).forEach((audit)=>{
+                lines.push(`   • ${audit.packageName}: cd ${audit.path} && git merge origin/${audit.status.conflictsWith}`);
+            });
+            lines.push('   Then resolve conflicts, commit, and push.');
+            lines.push('');
+        }
+        if (result.versionIssues > 0) {
+            lines.push(`${stepNumber}️⃣  FIX VERSION ISSUES (recommended before publish):`);
+            stepNumber++;
+            sortedAudits.filter((a)=>a.versionStatus && !a.versionStatus.isValid).forEach((audit)=>{
+                lines.push(`   • ${audit.packageName}: cd ${audit.path} && kodrdriv development`);
+            });
+            lines.push('');
+        }
+        if (prCount > 0) {
+            lines.push(`${stepNumber}️⃣  HANDLE EXISTING PRS:`);
+            stepNumber++;
+            sortedAudits.filter((a)=>a.status.hasOpenPR).forEach((audit)=>{
+                lines.push(`   • ${audit.packageName}: Review ${audit.status.prUrl}`);
+                lines.push(`     Option: Continue (publish will reuse PR) or close/merge it first`);
+            });
+            lines.push('');
+        }
+        if (branchInconsistentCount > 0) {
+            lines.push(`${stepNumber}️⃣  ALIGN BRANCHES (if needed):`);
+            stepNumber++;
+            sortedAudits.filter((a)=>!a.status.isOnExpectedBranch).forEach((audit)=>{
+                lines.push(`   • ${audit.packageName}: cd ${audit.path} && git checkout ${audit.status.expectedBranch}`);
+            });
+            lines.push('');
+        }
+        if (behindCount > 0) {
+            lines.push(`${stepNumber}️⃣  SYNC WITH REMOTE:`);
+            stepNumber++;
+            sortedAudits.filter((a)=>a.status.needsSync && !a.status.hasMergeConflicts).forEach((audit)=>{
+                lines.push(`   • ${audit.packageName}: cd ${audit.path} && git pull origin ${audit.status.name}`);
+            });
+            lines.push('');
+        }
+        if (unpushedCount > 0) {
+            lines.push(`${stepNumber}️⃣  PUSH LOCAL COMMITS:`);
+            stepNumber++;
+            sortedAudits.filter((a)=>a.status.hasUnpushedCommits && !a.status.hasMergeConflicts).forEach((audit)=>{
+                lines.push(`   • ${audit.packageName}: cd ${audit.path} && git push origin ${audit.status.name}`);
+            });
+            lines.push('');
+        }
+        if (noRemoteCount > 0) {
+            lines.push(`${stepNumber}️⃣  CREATE REMOTE BRANCHES:`);
+            stepNumber++;
+            sortedAudits.filter((a)=>!a.status.remoteExists).forEach((audit)=>{
+                lines.push(`   • ${audit.packageName}: cd ${audit.path} && git push -u origin ${audit.status.name}`);
+            });
+            lines.push('');
+        }
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('');
+        lines.push('🔄 After fixing issues, re-run audit to verify:');
+        lines.push('   kodrdriv tree publish --audit-branches');
+        lines.push('');
+        lines.push('✅ Once all clear, proceed with publish:');
+        lines.push('   kodrdriv tree publish --parallel --model "gpt-5-mini"');
+    }
+    lines.push('╚══════════════════════════════════════════════════════════════╝');
+    return lines.join('\n');
+}
+
+export { auditBranchState, checkBranchStatus, checkTargetBranchSync, formatAuditResults };
+//# sourceMappingURL=branchState-CtywDSJf.js.map