@eldrforge/kodrdriv 1.2.29 → 1.2.124

package/dist/utils/branchState.js

@@ -1,20 +1,38 @@
 import { run } from '@eldrforge/git-tools';
 import { getLogger } from '../logging.js';
+import { getGitRepositoryRoot, isInGitRepository } from '../util/gitMutex.js';
 
 /**
  * Check the branch status for a package
- */ async function checkBranchStatus(packagePath, expectedBranch, targetBranch = 'main', checkPR = false) {
+ */ async function checkBranchStatus(packagePath, expectedBranch, targetBranch = 'main', checkPR = false, options = {}) {
     const logger = getLogger();
-    const originalCwd = process.cwd();
+    // 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 {
-        process.chdir(packagePath);
         // Get current branch
-        const { stdout: currentBranch } = await run('git rev-parse --abbrev-ref HEAD');
+        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}`);
+            await run(`git ls-remote --exit-code --heads origin ${branch}`, {
+                cwd: packagePath,
+                suppressErrorLogging: true
+            });
             remoteExists = true;
         } catch  {
             remoteExists = false;
@@ -24,7 +42,10 @@ import { getLogger } from '../logging.js';
         let behind = 0;
         if (remoteExists) {
             try {
-                const { stdout: revList } = await run(`git rev-list --left-right --count origin/${branch}...HEAD`);
+                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;
@@ -38,11 +59,19 @@ import { getLogger } from '../logging.js';
         if (branch !== targetBranch) {
             try {
                 // Fetch latest to ensure we're checking against current target
-                logger.verbose(`    Fetching latest from origin for ${packagePath}...`);
-                await run('git fetch origin --quiet');
+                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}`);
+                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;
@@ -62,7 +91,7 @@ import { getLogger } from '../logging.js';
             try {
                 logger.verbose(`    Checking GitHub for existing PRs...`);
                 const { findOpenPullRequestByHeadRef } = await import('@eldrforge/github-tools');
-                const pr = await findOpenPullRequestByHeadRef(branch);
+                const pr = await findOpenPullRequestByHeadRef(branch, packagePath);
                 if (pr) {
                     hasOpenPR = true;
                     prUrl = pr.html_url;
@@ -91,28 +120,54 @@ import { getLogger } from '../logging.js';
             prUrl,
             prNumber
         };
-    } finally{
-        process.chdir(originalCwd);
+    } 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') {
+ */ async function checkTargetBranchSync(packagePath, targetBranch = 'main', options = {}) {
     const logger = getLogger();
-    const originalCwd = process.cwd();
+    // Check if path is in a git repository
+    if (!isInGitRepository(packagePath)) {
+        return {
+            targetBranch,
+            localExists: false,
+            remoteExists: false,
+            exactMatch: true,
+            canFastForward: false,
+            needsReset: false
+        };
+    }
     try {
-        process.chdir(packagePath);
         // Fetch latest from origin to ensure we have current info
-        try {
-            await run('git fetch origin --quiet');
-        } catch (error) {
-            logger.verbose(`Could not fetch from origin in ${packagePath}: ${error.message}`);
+        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}`);
+            const { stdout } = await run(`git rev-parse --verify ${targetBranch}`, {
+                cwd: packagePath,
+                suppressErrorLogging: true
+            });
             localSha = stdout.trim();
             localExists = true;
         } catch  {
@@ -122,7 +177,10 @@ import { getLogger } from '../logging.js';
         let remoteExists = false;
         let remoteSha;
         try {
-            const { stdout } = await run(`git ls-remote origin ${targetBranch}`);
+            const { stdout } = await run(`git ls-remote origin ${targetBranch}`, {
+                cwd: packagePath,
+                suppressErrorLogging: true
+            });
             if (stdout.trim()) {
                 remoteSha = stdout.split(/\s+/)[0];
                 remoteExists = true;
@@ -137,7 +195,10 @@ import { getLogger } from '../logging.js';
         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}`);
+                await run(`git merge-base --is-ancestor ${targetBranch} origin/${targetBranch}`, {
+                    cwd: packagePath,
+                    suppressErrorLogging: true
+                });
                 canFastForward = true;
                 needsReset = false;
             } catch  {
@@ -166,50 +227,118 @@ import { getLogger } from '../logging.js';
             needsReset: false,
             error: error.message
         };
-    } finally{
-        process.chdir(originalCwd);
     }
 }
 /**
  * Audit branch state across multiple packages
  */ async function auditBranchState(packages, expectedBranch, options = {}) {
     const logger = getLogger();
-    const audits = [];
     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
-    logger.info(`BRANCH_STATE_AUDIT: Auditing branch state for packages | Package Count: ${packages.length} | Purpose: Verify synchronization`);
+    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();
-        logger.info('📋 Phase 1/2: Detecting most common branch across packages...');
-        // First pass: collect all branch names
-        for(let i = 0; i < packages.length; i++){
-            const pkg = packages[i];
-            logger.info(`  [${i + 1}/${packages.length}] Checking branch: ${pkg.name}`);
-            const status = await checkBranchStatus(pkg.path);
-            branchCounts.set(status.name, (branchCounts.get(status.name) || 0) + 1);
+        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) {
+            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)`);
     }
-    logger.info(`\n📋 Phase 2/2: Auditing package state (checking git status, conflicts, PRs, versions)...`);
-    for(let i = 0; i < packages.length; i++){
-        const pkg = packages[i];
-        logger.info(`  [${i + 1}/${packages.length}] Auditing: ${pkg.name}`);
-        const status = await checkBranchStatus(pkg.path, actualExpectedBranch, targetBranch, checkPR);
+    // 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}')`);
@@ -261,7 +390,6 @@ import { getLogger } from '../logging.js';
             }
         }
         // Check target branch sync (e.g., is local main exactly in sync with remote main?)
-        const targetBranchSync = await checkTargetBranchSync(pkg.path, targetBranch);
         if (targetBranchSync.localExists && targetBranchSync.remoteExists && !targetBranchSync.exactMatch) {
             if (targetBranchSync.needsReset) {
                 issues.push(`Target branch '${targetBranch}' is NOT in sync with remote (local has diverged)`);
@@ -274,12 +402,17 @@ import { getLogger } from '../logging.js';
                 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 (this is OK - will be created during publish)
-            logger.verbose(`Local ${targetBranch} doesn't exist in ${pkg.name} - will be created when needed`);
+            // 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}`);
         }
-        audits.push({
+        completedCount++;
+        if (completedCount % 5 === 0 || completedCount === packages.length) {
+            logger.info(`  Progress: ${completedCount}/${packages.length} packages audited`);
+        }
+        return {
             packageName: pkg.name,
             path: pkg.path,
             status,
@@ -287,8 +420,8 @@ import { getLogger } from '../logging.js';
             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;