@docupace/pipeline 1.0.60 → 1.0.61-alpha.1

package/src/merge/cli-merge.js

@@ -0,0 +1,492 @@
+import { execSync } from 'child_process';
+import { createBitbucketPR } from './pr.js';
+import { autoResolveConflicts } from './cli-resolve.js';
+import { getPackageNames } from '../changeset/package-util.js';
+import { writeChangesetFile } from '../changeset/create.js';
+
+/**
+ * Create and checkout merge branch from target branch
+ */
+function createMergeBranch(
+  sourceBranch,
+  targetBranch,
+  checkoutOnly = false,
+  verbose = false,
+) {
+  const mergeBranchName = `merge/${sourceBranch.replaceAll('/', '-')}-to-${targetBranch.replaceAll('/', '-')}`;
+
+  if (!checkoutOnly) {
+    if (verbose) console.log(`📋 Checking out target branch: ${targetBranch}`);
+    execSync(`git checkout ${targetBranch}`, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+    execSync(`git pull origin ${targetBranch}`, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+
+    // Check if merge branch exists and delete it (both local and remote)
+    try {
+      execSync(`git branch -D ${mergeBranchName}`, {
+        stdio: 'pipe',
+      });
+      if (verbose)
+        console.log(`🗑️  Deleted existing local branch: ${mergeBranchName}`);
+    } catch {
+      // Branch doesn't exist, which is fine
+    }
+
+    // Try to delete remote branch
+    try {
+      execSync(`git push origin --delete ${mergeBranchName}`, {
+        stdio: 'pipe',
+      });
+      if (verbose)
+        console.log(`🗑️  Deleted existing remote branch: ${mergeBranchName}`);
+    } catch {
+      // Remote branch doesn't exist, which is fine
+    }
+
+    if (verbose) console.log(`🌿 Creating merge branch: ${mergeBranchName}`);
+    execSync(`git checkout -b ${mergeBranchName}`, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+  } else {
+    console.log('Do nothing. Should be checked out');
+  }
+
+  return mergeBranchName;
+}
+
+/**
+ * Attempt to merge source branch into current branch
+ * Returns: { hasConflicts: boolean, hasChanges: boolean }
+ */
+function attemptMerge(sourceBranch, targetBranch, verbose = false) {
+  if (verbose) {
+    console.log(`🔀 Merging ${sourceBranch} into current branch`);
+  }
+
+  try {
+    execSync(`git merge --no-commit --no-ff origin/${sourceBranch}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+
+    // Check if there are any changes
+    try {
+      execSync('git diff --cached --quiet', { stdio: 'pipe' });
+      // No changes
+      return { hasConflicts: false, hasChanges: false };
+    } catch {
+      // Has changes
+      if (verbose) console.log('✅ Merge completed with changes, no conflicts');
+      return { hasConflicts: false, hasChanges: true };
+    }
+  } catch (error) {
+    if (verbose) console.log('⚠️  Merge conflicts detected');
+    return { hasConflicts: true, hasChanges: true };
+  }
+}
+
+/**
+ * Get packages that have changes to be merged
+ */
+function getChangedPackages(verbose = false) {
+  try {
+    const allPackages = getPackageNames();
+
+    // Get list of changed files
+    const changedFiles = execSync('git diff --cached --name-only', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    })
+      .trim()
+      .split('\n')
+      .filter(Boolean);
+
+    if (verbose) {
+      console.log('📄 Changed files:', changedFiles);
+    }
+
+    // Filter packages that have changes
+    const changedPackages = allPackages.filter((pkg) => {
+      const packagePath = pkg.path === '.' ? '' : pkg.path + '/';
+      return changedFiles.some((file) => file.startsWith(packagePath));
+    });
+
+    if (verbose) {
+      console.log(
+        '📦 Changed packages:',
+        changedPackages.map((p) => p.name),
+      );
+    }
+
+    return changedPackages;
+  } catch (error) {
+    if (verbose) console.log('Error getting changed packages:', error.message);
+    return [];
+  }
+}
+
+/**
+ * Run build script
+ */
+function runBuild(buildScript, verbose = false) {
+  if (verbose) console.log(`🔨 Running build: ${buildScript}`);
+
+  try {
+    execSync(buildScript, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+    if (verbose) console.log('✅ Build passed');
+    return true;
+  } catch (error) {
+    if (verbose) console.log('❌ Build failed');
+    return false;
+  }
+}
+
+/**
+ * Create changeset and commit it
+ */
+async function createAndCommitChangeset(
+  sourceBranch,
+  targetBranch,
+  changedPackages,
+  verbose = false,
+) {
+  const changesetId = `merge-${sourceBranch.replaceAll('/', '-')}-to-${targetBranch.replaceAll('/', '-')}-${Date.now()}`;
+  const text = `Merge ${sourceBranch} to ${targetBranch}`;
+
+  if (verbose) console.log('📝 Creating changeset...');
+
+  await writeChangesetFile(changedPackages, changesetId, 'patch', text);
+
+  execSync('git add .', {
+    stdio: verbose ? 'inherit' : 'pipe',
+  });
+
+  execSync(
+    `git commit -m "Automatic merge operation for ${sourceBranch} to ${targetBranch}"`,
+    {
+      stdio: verbose ? 'inherit' : 'pipe',
+    },
+  );
+
+  if (verbose) console.log('✅ Changeset created and committed');
+}
+
+/**
+ * Merge into target branch
+ */
+
+function branchExists(branchName) {
+  try {
+    // This will list branches that match the name
+    const result = execSync(`git branch --list ${branchName}`, {
+      encoding: 'utf8',
+    });
+    return result.trim().length > 0;
+  } catch (error) {
+    // If git fails, you can log or handle differently
+    console.error('Error checking branch:', error.message);
+    return false;
+  }
+}
+
+function mergeIntoTarget(
+  sourceBranch,
+  targetBranch,
+  mergeBranchName,
+  verbose = false,
+) {
+  if (verbose)
+    console.log(`🔀 Merging ${mergeBranchName} into ${targetBranch}`);
+
+  execSync(`git checkout ${targetBranch}`, {
+    stdio: verbose ? 'inherit' : 'pipe',
+  });
+
+  if (branchExists(mergeBranchName)) {
+    execSync(`git merge ${mergeBranchName}`, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+
+    execSync(`git push origin ${targetBranch}`, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+
+    execSync(`git branch -d ${mergeBranchName}`, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+
+    if (verbose) console.log(`✅ Successfully merged into ${targetBranch}`);
+  } else {
+    if (verbose) console.log(`✅ Nothing to merge`);
+  }
+}
+
+/**
+ * Create pull request for merge branch
+ */
+async function createMergePR(
+  sourceBranch,
+  targetBranch,
+  mergeBranchName,
+  reason,
+  verbose = false,
+) {
+  if (verbose) console.log('📋 Creating pull request...');
+
+  const prTitle = `Merge ${sourceBranch} into ${targetBranch}`;
+  const prDescription = `Automated merge with changeset.\n\nReason: ${reason}`;
+
+  const prResult = await createBitbucketPR(
+    mergeBranchName,
+    targetBranch,
+    prTitle,
+    prDescription,
+  );
+
+  if (prResult.success) {
+    console.log(`✅ Pull request created: ${prResult.url}`);
+  } else if (prResult.manual) {
+    console.log(`📋 Please create PR manually: ${prResult.url}`);
+  } else {
+    console.log(`❌ Failed to create pull request: ${prResult.error}`);
+  }
+}
+
+/**
+ * Clean up failed merge
+ */
+function cleanupFailedMerge(verbose = false) {
+  try {
+    execSync('git merge --abort', { stdio: 'pipe' });
+    if (verbose) console.log('🧹 Cleaned up failed merge');
+  } catch (cleanupError) {
+    // Ignore cleanup errors
+  }
+}
+
+export function setupMerge(program) {
+  program
+    .command('merge')
+    .description(
+      'Merge source branch into target branch with automatic conflict resolution',
+    )
+    .argument('<sourceBranch>', 'Source branch to merge from')
+    .argument('<targetBranch>', 'Target branch to merge into')
+    .requiredOption('-b, --build <script>', 'Build script to run after merge')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--no-push', 'Do not push changes automatically')
+    .option('--no-pr', 'Do not create pull request if conflicts remain')
+    .option(
+      '--prepare-only',
+      'Always create PR instead of direct merge, even if build passes',
+    )
+    .option('--merge-success', 'Merge with success')
+    .option('--merge-fail <reason>', 'Merge with with fail')
+    .action(async (sourceBranch, targetBranch, options) => {
+      try {
+        const {
+          verbose,
+          push = true,
+          pr = true,
+          build,
+          prepareOnly = false,
+          mergeSuccess = false,
+          mergeFail = '',
+        } = options;
+        const isDevMode = process.env.DEV_MODE === 'true';
+
+        if (verbose) {
+          console.log(
+            `🔄 Starting merge of ${sourceBranch} into ${targetBranch}`,
+          );
+        }
+
+        // 1. Create merge branch from target branch
+        const mergeBranchName = createMergeBranch(
+          sourceBranch,
+          targetBranch,
+          mergeSuccess || mergeFail,
+          verbose,
+        );
+
+        if (!mergeFail && !mergeSuccess) {
+          // 2. Attempt merge
+          const { hasConflicts, hasChanges } = attemptMerge(
+            sourceBranch,
+            targetBranch,
+            verbose,
+          );
+
+          // 3. If no changes, exit
+          if (!hasChanges) {
+            console.log('✅ No changes to merge');
+            execSync(`git checkout ${targetBranch}`, { stdio: 'pipe' });
+            execSync(`git branch -d ${mergeBranchName}`, { stdio: 'pipe' });
+            return;
+          }
+
+          // 4. If conflicts, try auto-resolve
+          let allConflictsResolved = true;
+          if (hasConflicts) {
+            if (verbose) console.log('🤖 Running auto-conflict resolution...');
+
+            const autoResult = await autoResolveConflicts({ verbose });
+            allConflictsResolved = autoResult.success;
+          }
+
+          // Get changed packages
+          const changedPackages = getChangedPackages(verbose);
+
+          if (!allConflictsResolved) {
+            // 5. Cannot resolve conflicts
+            if (verbose)
+              console.log('⚠️  Cannot resolve all conflicts automatically');
+
+            // 5a) Get changed packages (already done above)
+            // 5b) Abort merge
+            cleanupFailedMerge(verbose);
+
+            // 5c) Create changeset
+            await createAndCommitChangeset(
+              sourceBranch,
+              targetBranch,
+              changedPackages,
+              verbose,
+            );
+
+            if (pr && !prepareOnly) {
+              // 5d) Push and create PR
+              if (push) {
+                execSync(`git push -u origin ${mergeBranchName}`, {
+                  stdio: verbose ? 'inherit' : 'pipe',
+                });
+              }
+
+              await createMergePR(
+                sourceBranch,
+                targetBranch,
+                mergeBranchName,
+                'Unresolved conflicts',
+                verbose,
+              );
+            } else {
+              console.log(
+                `⚠️  Merge completed with unresolved conflicts on branch: ${mergeBranchName}`,
+              );
+              process.exit(2);
+            }
+
+            console.log(
+              `⚠️  Merge completed with unresolved conflicts on branch: ${mergeBranchName}`,
+            );
+            return;
+          }
+
+          // 6. Can resolve conflicts
+          if (verbose) console.log('✅ All conflicts resolved');
+
+          // 6a) Get changed packages (already done above)
+          // 6b) Create changeset
+          await createAndCommitChangeset(
+            sourceBranch,
+            targetBranch,
+            changedPackages,
+            verbose,
+          );
+
+          // 6c) Run build
+          const buildPassed = runBuild(build, verbose);
+
+          if (buildPassed && !isDevMode && !prepareOnly) {
+            // 6d) Build passed - merge into target
+            mergeIntoTarget(
+              sourceBranch,
+              targetBranch,
+              mergeBranchName,
+              verbose,
+            );
+            console.log(
+              `🎉 Successfully merged ${sourceBranch} into ${targetBranch}`,
+            );
+          } else if (prepareOnly) {
+            if (push) {
+              execSync(`git push -u origin ${mergeBranchName}`, {
+                stdio: verbose ? 'inherit' : 'pipe',
+              });
+            }
+            if (buildPassed) {
+              process.exit(0);
+            } else {
+              process.exit(3);
+            }
+          } else {
+            // 6e) Build failed, dev mode, or prepare-only - create PR
+            if (push) {
+              execSync(`git push -u origin ${mergeBranchName}`, {
+                stdio: verbose ? 'inherit' : 'pipe',
+              });
+            }
+
+            if (pr) {
+              let reason;
+              if (isDevMode) {
+                reason = 'Dev mode enabled';
+              } else {
+                reason = 'Build failed';
+              }
+
+              await createMergePR(
+                sourceBranch,
+                targetBranch,
+                mergeBranchName,
+                reason,
+                verbose,
+              );
+            }
+
+            let reason;
+            if (prepareOnly) {
+              reason = 'prepare-only mode';
+            } else if (isDevMode) {
+              reason = 'dev mode';
+            } else {
+              reason = 'build failure';
+            }
+
+            console.log(
+              `⚠️  Merge completed but creating PR due to ${reason}: ${mergeBranchName}`,
+            );
+          }
+        } else {
+          if (mergeSuccess) {
+            mergeIntoTarget(
+              sourceBranch,
+              targetBranch,
+              mergeBranchName,
+              verbose,
+            );
+          } else {
+            execSync(`git push -u origin ${mergeBranchName}`, {
+              stdio: verbose ? 'inherit' : 'pipe',
+            });
+            await createMergePR(
+              sourceBranch,
+              targetBranch,
+              mergeBranchName,
+              mergeFail,
+              verbose,
+            );
+          }
+        }
+      } catch (error) {
+        console.error(`❌ Merge failed: ${error.message}`);
+        cleanupFailedMerge();
+        process.exit(1);
+      }
+    });
+}