@docupace/pipeline 1.0.62 → 1.0.64-alpha.0

package/src/merge/cli-merge-all.js

@@ -0,0 +1,472 @@
+import { execSync } from 'child_process';
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Read merge configuration from current directory
+ */
+function readMergeConfig(verbose = false) {
+  const configPath = join(process.cwd(), 'merge-config.json');
+
+  if (!existsSync(configPath)) {
+    throw new Error('merge-config.json not found in current directory');
+  }
+
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+
+    if (!config.repositories || !Array.isArray(config.repositories)) {
+      throw new Error('Invalid config: repositories array is required');
+    }
+
+    // Validate repository objects
+    config.repositories.forEach((repo, index) => {
+      if (!repo.url) {
+        throw new Error(`Repository at index ${index} is missing 'url' field`);
+      }
+      if (!repo.buildScript) {
+        throw new Error(
+          `Repository at index ${index} is missing 'buildScript' field`,
+        );
+      }
+      if (!repo.name) {
+        throw new Error(`Repository at index ${index} is missing 'name' field`);
+      }
+    });
+
+    if (!config.mergeBranches || !Array.isArray(config.mergeBranches)) {
+      throw new Error('Invalid config: mergeBranches array is required');
+    }
+
+    // Validate merge branches
+    config.mergeBranches.forEach((branch, index) => {
+      if (!branch.from || !branch.to) {
+        throw new Error(
+          `Merge branch at index ${index} is missing 'from' or 'to' field`,
+        );
+      }
+      if (typeof branch.from !== 'object' || typeof branch.to !== 'object') {
+        throw new Error(
+          `Merge branch at index ${index}: 'from' and 'to' must be objects`,
+        );
+      }
+      if (!branch.from['*'] || !branch.to['*']) {
+        throw new Error(
+          `Merge branch at index ${index}: 'from' and 'to' must have '*' default value`,
+        );
+      }
+    });
+
+    if (verbose) {
+      console.log('📋 Configuration loaded:');
+      console.log(`  Repositories: ${config.repositories.length}`);
+      console.log(`  Merge branches: ${config.mergeBranches.length}`);
+    }
+
+    return config;
+  } catch (error) {
+    throw new Error(`Failed to parse merge-config.json: ${error.message}`);
+  }
+}
+
+/**
+ * Extract repository name from git URL
+ */
+function getRepoName(gitUrl) {
+  const match = gitUrl.match(/\/([^\/]+)\.git$/);
+  return match ? match[1] : gitUrl.split('/').pop().replace('.git', '');
+}
+
+/**
+ * Get branch name for a specific repository
+ */
+function getBranchForRepo(branchConfig, repoName) {
+  // Check if there's a specific override for this repository
+  if (branchConfig[repoName]) {
+    return branchConfig[repoName];
+  }
+  // Fall back to the default branch
+  return branchConfig['*'];
+}
+
+/**
+ * Clone or update repository
+ */
+function setupRepository(repository, reposDir, verbose = false) {
+  const repoName = getRepoName(repository.url);
+  const repoPath = join(reposDir, repoName);
+
+  if (existsSync(repoPath)) {
+    if (verbose) console.log(`📁 Repository ${repoName} exists, updating...`);
+
+    execSync('git fetch --all', {
+      cwd: repoPath,
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+  } else {
+    if (verbose) console.log(`📥 Cloning repository ${repoName}...`);
+
+    execSync(`git clone ${repository.url} ${repoName}`, {
+      cwd: reposDir,
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+  }
+
+  return {
+    repoName,
+    repoPath,
+    buildScript: repository.buildScript,
+    configName: repository.name,
+  };
+}
+
+/**
+ * Run merge command in repository with specific flags
+ */
+function runMergeCommand(
+  repoPath,
+  fromBranch,
+  toBranch,
+  buildScript,
+  flags = '',
+  verbose = false,
+) {
+  const cliPath = join(__dirname, 'cli.js');
+  const verboseFlag = verbose ? '--verbose' : '';
+
+  const command =
+    `node ${cliPath} merge ${fromBranch} ${toBranch} --build "${buildScript}" ${flags} ${verboseFlag}`.trim();
+
+  if (verbose) {
+    console.log(`📄 Running command in ${repoPath}`);
+    console.log(`Command: ${command}`);
+  }
+
+  try {
+    execSync(command, {
+      cwd: repoPath,
+      stdio: verbose ? 'inherit' : 'pipe',
+      encoding: 'utf8',
+    });
+
+    return { exitCode: 0, error: null };
+  } catch (error) {
+    // Extract exit code from error
+    const exitCode = error.status || 1;
+    return { exitCode, error: error.message };
+  }
+}
+
+/**
+ * Run initial prepare-only phase for all repositories
+ */
+async function runPreparePhase(
+  mergeBranch,
+  repositories,
+  reposDir,
+  verbose = false,
+) {
+  const { from: fromConfig, to: toConfig } = mergeBranch;
+  console.log(`\n🔄 Phase 1: Running prepare-only for all repositories`);
+
+  const results = [];
+
+  for (let i = 0; i < repositories.length; i++) {
+    const repository = repositories[i];
+    const { repoName, repoPath, buildScript, configName } = setupRepository(
+      repository,
+      reposDir,
+      verbose,
+    );
+
+    // Get the specific branches for this repository
+    const fromBranch = getBranchForRepo(fromConfig, configName);
+    const toBranch = getBranchForRepo(toConfig, configName);
+
+    console.log(
+      `\n📦 [${i + 1}/${repositories.length}] Testing ${configName} (${repoName}): ${fromBranch} → ${toBranch}`,
+    );
+
+    const result = runMergeCommand(
+      repoPath,
+      fromBranch,
+      toBranch,
+      buildScript,
+      '--prepare-only',
+      verbose,
+    );
+
+    results.push({
+      repository: repoName,
+      configName,
+      url: repository.url,
+      buildScript,
+      fromBranch,
+      toBranch,
+      exitCode: result.exitCode,
+      error: result.error,
+      repoPath,
+    });
+
+    // Log result based on exit code
+    switch (result.exitCode) {
+      case 0:
+        console.log(`✅ ${configName}: Merge and build successful`);
+        break;
+      case 2:
+        console.log(`⚠️ ${configName}: Merge has unresolved conflicts`);
+        break;
+      case 3:
+        console.log(`⚠️ ${configName}: Build failed`);
+        break;
+      default:
+        console.log(
+          `❌ ${configName}: Unknown error (exit code: ${result.exitCode})`,
+        );
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Run follow-up phase based on prepare phase results
+ */
+async function runFollowUpPhase(prepareResults, verbose = false) {
+  console.log(`\n🔄 Phase 2: Running follow-up based on prepare phase results`);
+
+  // Check if all repositories passed
+  const allPassed = prepareResults.every((r) => r.exitCode === 0);
+
+  for (let i = 0; i < prepareResults.length; i++) {
+    const result = prepareResults[i];
+    console.log(
+      `\n📦 [${i + 1}/${prepareResults.length}] Processing ${result.configName}`,
+    );
+
+    let flags = '';
+    let action = '';
+
+    if (allPassed) {
+      // All passed, merge successfully
+      flags = '--merge-success';
+      action = 'Merging successfully';
+    } else {
+      // At least one failed, determine the appropriate action
+      switch (result.exitCode) {
+        case 0:
+          // This one passed but others failed
+          flags = '--merge-fail "Waiting for success for other failed merges"';
+          action = 'Creating PR (waiting for other repos)';
+          break;
+        case 2:
+          // Merge failed
+          flags = '--merge-fail "Merge Failed"';
+          action = 'Creating PR (merge conflicts)';
+          break;
+        case 3:
+          // Build failed
+          flags = '--merge-fail "Build Failed"';
+          action = 'Creating PR (build failed)';
+          break;
+        default:
+          // Unknown error
+          flags = '--merge-fail "Unknown Error"';
+          action = 'Creating PR (unknown error)';
+      }
+    }
+
+    console.log(`  Action: ${action}`);
+
+    const followUpResult = runMergeCommand(
+      result.repoPath,
+      result.fromBranch,
+      result.toBranch,
+      result.buildScript,
+      flags,
+      verbose,
+    );
+
+    // Update the result with follow-up information
+    result.followUpExitCode = followUpResult.exitCode;
+    result.followUpError = followUpResult.error;
+    result.followUpAction = action;
+
+    if (followUpResult.exitCode === 0) {
+      console.log(`✅ ${result.configName}: ${action} completed`);
+    } else {
+      console.log(`❌ ${result.configName}: ${action} failed`);
+    }
+  }
+
+  return prepareResults;
+}
+
+/**
+ * Process a single merge branch across all repositories
+ */
+async function processMergeBranch(
+  mergeBranch,
+  repositories,
+  reposDir,
+  verbose = false,
+) {
+  console.log(`\n🔀 Processing merge branches`);
+
+  // Phase 1: Run prepare-only for all repositories
+  const prepareResults = await runPreparePhase(
+    mergeBranch,
+    repositories,
+    reposDir,
+    verbose,
+  );
+
+  // Phase 2: Run follow-up based on results
+  const finalResults = await runFollowUpPhase(prepareResults, verbose);
+
+  // Summary
+  const allPassed = prepareResults.every((r) => r.exitCode === 0);
+  const mergeFailures = prepareResults.filter((r) => r.exitCode === 2);
+  const buildFailures = prepareResults.filter((r) => r.exitCode === 3);
+  const successes = prepareResults.filter((r) => r.exitCode === 0);
+
+  console.log(`\n📊 Merge summary:`);
+  console.log(`  ✅ Successful: ${successes.length}/${repositories.length}`);
+  console.log(`  ⚠️ Merge conflicts: ${mergeFailures.length}`);
+  console.log(`  ⚠️ Build failures: ${buildFailures.length}`);
+
+  if (allPassed) {
+    console.log(`  🎉 All repositories merged successfully!`);
+  } else {
+    console.log(`  ⚠️ Some repositories require manual intervention via PRs`);
+  }
+
+  return {
+    success: allPassed,
+    results: finalResults,
+    summary: {
+      total: repositories.length,
+      successes: successes.length,
+      mergeFailures: mergeFailures.length,
+      buildFailures: buildFailures.length,
+    },
+  };
+}
+
+/**
+ * Main merge-all function
+ */
+async function mergeAll(verbose = false) {
+  try {
+    // Read configuration
+    const config = readMergeConfig(verbose);
+
+    // Setup repos directory
+    const reposDir = join(process.cwd(), 'repos');
+    if (!existsSync(reposDir)) {
+      mkdirSync(reposDir, { recursive: true });
+      if (verbose) console.log(`📁 Created repos directory: ${reposDir}`);
+    }
+
+    console.log(`🚀 Starting merge-all process`);
+    console.log(`Repositories: ${config.repositories.length}`);
+    console.log(`Merge branches: ${config.mergeBranches.length}`);
+
+    const allResults = [];
+
+    // Process each merge branch in sequence
+    for (let i = 0; i < config.mergeBranches.length; i++) {
+      const mergeBranch = config.mergeBranches[i];
+      console.log(`\n═══════════════════════════════════════`);
+      console.log(
+        `Processing merge branch set ${i + 1}/${config.mergeBranches.length}`,
+      );
+      console.log(`═══════════════════════════════════════`);
+
+      const branchResult = await processMergeBranch(
+        mergeBranch,
+        config.repositories,
+        reposDir,
+        verbose,
+      );
+
+      if (!branchResult.success) {
+        console.log(`Exiting due to failure of one or more merges`);
+        process.exit(1);
+      }
+
+      allResults.push({
+        mergeBranch,
+        ...branchResult,
+      });
+    }
+
+    // Final summary
+    console.log(`\n═══════════════════════════════════════`);
+    console.log(`📈 Final Summary:`);
+    console.log(`═══════════════════════════════════════`);
+
+    allResults.forEach((result, index) => {
+      const { from, to } = result.mergeBranch;
+      const status = result.success ? '✅' : '⚠️';
+      console.log(`\n${status} Merge branch set ${index + 1}:`);
+
+      if (result.summary) {
+        console.log(`  Total repositories: ${result.summary.total}`);
+        console.log(`  Successful merges: ${result.summary.successes}`);
+        console.log(`  Merge conflicts: ${result.summary.mergeFailures}`);
+        console.log(`  Build failures: ${result.summary.buildFailures}`);
+      }
+
+      if (result.results && verbose) {
+        console.log(`\n  Repository details:`);
+        result.results.forEach((repo) => {
+          let repoStatus = '❓';
+          if (repo.exitCode === 0) repoStatus = '✅';
+          else if (repo.exitCode === 2) repoStatus = '⚠️ (merge)';
+          else if (repo.exitCode === 3) repoStatus = '⚠️ (build)';
+
+          console.log(
+            `    ${repoStatus} ${repo.configName}: ${repo.fromBranch} → ${repo.toBranch}`,
+          );
+        });
+      }
+    });
+
+    const overallSuccess = allResults.every((r) => r.success);
+    if (overallSuccess) {
+      console.log(`\n🎉 All merge operations completed successfully!`);
+    } else {
+      console.log(
+        `\n⚠️ Some merge operations created PRs. Check the repositories for details.`,
+      );
+    }
+
+    return { success: overallSuccess, results: allResults };
+  } catch (error) {
+    console.error(`❌ Merge-all failed: ${error.message}`);
+    throw error;
+  }
+}
+
+export function setupMergeAll(program) {
+  program
+    .command('merge-all')
+    .description(
+      'Merge multiple branches across multiple repositories based on configuration',
+    )
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (options) => {
+      try {
+        const { verbose } = options;
+
+        await mergeAll(verbose);
+      } catch (error) {
+        console.error(`❌ merge-all command failed: ${error.message}`);
+        process.exit(1);
+      }
+    });
+}