@docupace/pipeline 1.0.63 → 1.0.64

package/src/merge/cli-resolve.js

@@ -0,0 +1,395 @@
+import { mergeChangelogFile } from './merge-changelog.js';
+import mergeTypes, { mergeTypesFile } from './merge-types.js';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import mergePackageFile from './merge-package.js';
+import { execSync } from 'child_process';
+
+// Default merge configuration
+const defaultMergeConfig = {
+  'CHANGELOG.md': 'changelog',
+  '*/CHANGELOG.md': 'changelog',
+  '**/CHANGELOG.md': 'changelog',
+  'src/types/graphql.ts': 'types',
+  'codegen.ts': 'ours',
+  'package.json': 'package',
+  '*/package.json': 'package',
+  '**/package.json': 'package',
+};
+
+// Available merge strategies
+const mergeStrategies = {
+  changelog: mergeChangelogFile,
+  package: mergePackageFile,
+  types: mergeTypesFile,
+  ours: (filePath) => {
+    // Keep our version by checking out the HEAD version (removes conflicts)
+    try {
+      execSync(`git checkout --ours ${filePath}`);
+      execSync(`git add ${filePath}`);
+      console.log(
+        `📝 Using 'ours' strategy for ${filePath} - reset to HEAD version and marked as resolved`,
+      );
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to apply 'ours' strategy: ${error.message}`);
+    }
+  },
+  theirs: (filePath) => {
+    // Take their version
+    try {
+      execSync(`git checkout --theirs ${filePath}`);
+      execSync(`git add ${filePath}`);
+      console.log(
+        `📝 Using 'theirs' strategy for ${filePath} - marked as resolved`,
+      );
+      return true;
+    } catch (error) {
+      throw new Error(`Failed to apply 'theirs' strategy: ${error.message}`);
+    }
+  },
+};
+
+/**
+ * Get list of conflicted files from git status
+ */
+function getConflictedFiles() {
+  try {
+    const statusOutput = execSync('git status --porcelain', {
+      encoding: 'utf-8',
+    });
+    const conflictedFiles = statusOutput
+      .split('\n')
+      .filter(
+        (line) =>
+          line.startsWith('UU ') ||
+          line.startsWith('AA ') ||
+          line.startsWith('DD '),
+      )
+      .map((line) => line.substring(3).trim())
+      .filter((file) => file.length > 0);
+    return conflictedFiles;
+  } catch (error) {
+    throw new Error(`Failed to get git status: ${error.message}`);
+  }
+}
+
+/**
+ * Load merge configuration from .mergerc file or use defaults
+ */
+function loadMergeConfig() {
+  const configPath = '.mergerc';
+
+  if (existsSync(configPath)) {
+    try {
+      const configContent = readFileSync(configPath, 'utf-8');
+      const config = {};
+
+      configContent.split('\n').forEach((line) => {
+        line = line.trim();
+        if (line && !line.startsWith('#')) {
+          const [pattern, strategy] = line
+            .split(/\s+merge=/)
+            .map((s) => s.trim());
+          if (pattern && strategy) {
+            config[pattern] = strategy;
+          }
+        }
+      });
+
+      return config;
+    } catch (error) {
+      console.warn(
+        `Warning: Could not read ${configPath}, using defaults: ${error.message}`,
+      );
+    }
+  }
+
+  return defaultMergeConfig;
+}
+
+/**
+ * Match file path against patterns (supports * and ** wildcards)
+ */
+function matchPattern(filePath, pattern) {
+  // Handle ** at the beginning of pattern
+  if (pattern.startsWith('**/')) {
+    // Remove the **/ and check if the path ends with the remaining pattern
+    const remainingPattern = pattern.slice(3);
+    const regexPattern = remainingPattern
+      .replace(/\*/g, '[^/]*')
+      .replace(/\./g, '\\.')
+      .replace(/\//g, '\\/');
+
+    const regex = new RegExp(`(^|/)${regexPattern}$`);
+    return regex.test(filePath);
+  }
+
+  // For other cases, convert pattern to regex
+  const regexPattern = pattern
+    .replace(/\*\*/g, '___DOUBLESTAR___')
+    .replace(/\*/g, '[^/]*')
+    .replace(/___DOUBLESTAR___/g, '.*?')
+    .replace(/\./g, '\\.')
+    .replace(/\//g, '\\/');
+
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(filePath);
+}
+
+/**
+ * Find merge strategy for a given file
+ */
+function findMergeStrategy(filePath, config) {
+  // Check exact match first
+  if (config[filePath]) {
+    return config[filePath];
+  }
+
+  // Check pattern matches
+  for (const [pattern, strategy] of Object.entries(config)) {
+    if (matchPattern(filePath, pattern)) {
+      return strategy;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Create default .mergerc file
+ */
+function createDefaultConfig() {
+  const configContent = `# Merge configuration file
+# Format: <file-pattern> merge=<strategy>
+# Strategies: changelog, package, types, ours, theirs
+
+CHANGELOG.md merge=changelog
+*/CHANGELOG.md merge=changelog
+**/CHANGELOG.md merge=changelog
+src/types/graphql.ts merge=types
+codegen.ts merge=ours
+package.json merge=package
+*/package.json merge=package
+**/package.json merge=package
+`;
+
+  writeFileSync('.mergerc', configContent);
+  console.log('✅ Created default .mergerc configuration file');
+}
+
+export async function autoResolveConflicts(options = {}) {
+  const { dryRun = false, verbose = false } = options;
+
+  // Get conflicted files
+  const conflictedFiles = getConflictedFiles();
+
+  if (conflictedFiles.length === 0) {
+    if (verbose) console.log('✅ No conflicted files found');
+    return { success: true, resolvedCount: 0, skippedCount: 0, totalCount: 0 };
+  }
+
+  if (verbose) {
+    console.log(`Found ${conflictedFiles.length} conflicted files:`);
+    conflictedFiles.forEach((file) => console.log(`  - ${file}`));
+    console.log('');
+  }
+
+  // Load configuration
+  const config = loadMergeConfig();
+
+  if (verbose) {
+    console.log('Merge configuration:');
+    Object.entries(config).forEach(([pattern, strategy]) => {
+      console.log(`  ${pattern} -> ${strategy}`);
+    });
+    console.log('');
+  }
+
+  let resolvedCount = 0;
+  let skippedCount = 0;
+
+  // Process each conflicted file
+  for (const filePath of conflictedFiles) {
+    const strategy = findMergeStrategy(filePath, config);
+
+    if (!strategy) {
+      if (verbose)
+        console.log(`⚠️  No strategy found for ${filePath} - skipping`);
+      skippedCount++;
+      continue;
+    }
+
+    const mergeFunction = mergeStrategies[strategy];
+    if (!mergeFunction) {
+      if (verbose)
+        console.log(
+          `⚠️  Unknown strategy '${strategy}' for ${filePath} - skipping`,
+        );
+      skippedCount++;
+      continue;
+    }
+
+    if (dryRun) {
+      if (verbose)
+        console.log(`Would apply '${strategy}' strategy to ${filePath}`);
+      continue;
+    }
+
+    try {
+      if (verbose)
+        console.log(`🔧 Applying '${strategy}' strategy to ${filePath}`);
+      mergeFunction(filePath);
+      resolvedCount++;
+    } catch (error) {
+      console.error(`❌ Failed to resolve ${filePath}: ${error.message}`);
+      skippedCount++;
+    }
+  }
+
+  const result = {
+    success: skippedCount === 0,
+    resolvedCount,
+    skippedCount,
+    totalCount: conflictedFiles.length,
+  };
+
+  // Summary
+  if (verbose) {
+    console.log(`\n📊 Summary:`);
+    console.log(`  Resolved: ${resolvedCount}`);
+    console.log(`  Skipped: ${skippedCount}`);
+    console.log(`  Total: ${conflictedFiles.length}`);
+
+    if (resolvedCount > 0 && !dryRun) {
+      console.log(`\n✅ Successfully resolved ${resolvedCount} conflicts`);
+      if (skippedCount === 0) {
+        console.log(
+          '🎉 All conflicts resolved! You can now commit the changes.',
+        );
+      }
+    }
+  }
+
+  return result;
+}
+
+export function setupResolve(program) {
+  program
+    .command('resolve-conflicts')
+    .description('Automatically resolve conflicts based on configuration')
+    .option(
+      '-c, --config <path>',
+      'Path to merge configuration file',
+      '.mergerc',
+    )
+    .option('-n, --dry-run', 'Show what would be done without making changes')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (options) => {
+      try {
+        const result = await autoResolveConflicts(options);
+
+        if (!result.success) {
+          console.error(
+            `❌ Auto-resolve failed: ${result.skippedCount} files could not be resolved`,
+          );
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error(`❌ Auto-resolve failed: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // New merge command
+
+  // Individual strategy commands
+  program
+    .command('resolve-changelog-conflicts')
+    .description('Merge changelog files by removing conflict markers')
+    .argument('<file>', 'File with merge conflicts')
+    .action(async (file) => {
+      try {
+        mergeChangelogFile(file);
+        console.log('✅ Changelog merge completed successfully');
+      } catch (error) {
+        console.error(`❌ Changelog merge failed: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('resolve-package-conflicts')
+    .description('Merge package.json files by resolving version conflicts')
+    .argument('<file>', 'File with merge conflicts')
+    .action(async (file) => {
+      try {
+        await mergePackageFile(file);
+        console.log('✅ Package merge completed successfully');
+      } catch (error) {
+        console.error(`❌ Package merge failed: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('resolve-type-conflicts')
+    .description('Merge types files with balanced brace checking')
+    .argument('<file>', 'File with merge conflicts')
+    .action(async (file) => {
+      try {
+        await mergeTypes(file);
+        console.log('✅ Types merge completed successfully');
+      } catch (error) {
+        console.error(`❌ Types merge failed: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Configuration commands
+  program
+    .command('init')
+    .description('Create default .mergerc configuration file')
+    .action(() => {
+      if (existsSync('.mergerc')) {
+        console.log('⚠️  .mergerc already exists. Use --force to overwrite.');
+        return;
+      }
+      createDefaultConfig();
+    });
+
+  program
+    .command('config')
+    .description('Show current merge configuration')
+    .action(() => {
+      const config = loadMergeConfig();
+      console.log('Current merge configuration:');
+      Object.entries(config).forEach(([pattern, strategy]) => {
+        console.log(`  ${pattern.padEnd(30)} -> ${strategy}`);
+      });
+    });
+
+  program
+    .command('status')
+    .description('Show conflicted files and their assigned strategies')
+    .action(() => {
+      try {
+        const conflictedFiles = getConflictedFiles();
+        const config = loadMergeConfig();
+
+        if (conflictedFiles.length === 0) {
+          console.log('✅ No conflicted files found');
+          return;
+        }
+
+        console.log('Conflicted files and their strategies:');
+        conflictedFiles.forEach((file) => {
+          const strategy = findMergeStrategy(file, config);
+          const status = strategy ? `-> ${strategy}` : '-> no strategy';
+          console.log(`  ${file.padEnd(40)} ${status}`);
+        });
+      } catch (error) {
+        console.error(`❌ Failed to get status: ${error.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/merge/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import dotenv from 'dotenv';
+dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
+
+import { Command } from 'commander';
+import { setupMerge } from './cli-merge.js';
+import { setupResolve } from './cli-resolve.js';
+import { setupMergeAll } from './cli-merge-all.js';
+
+const args = process.argv;
+const program = new Command();
+
+/**
+ * Reusable auto-resolve function
+ * @param {Object} options - Options object with config, dryRun, verbose properties
+ * @returns {Object} - Result object with counts and success status
+ */
+
+// Main program
+program
+  .name('merge-cli')
+  .description(
+    'Automatically resolve git merge conflicts based on file patterns',
+  )
+  .version('1.0.0');
+
+// Auto-resolve command (now uses the reusable function)
+
+setupResolve(program);
+setupMerge(program);
+setupMergeAll(program);
+// Parse command line arguments
+program.parse(args);
+
+// Show help if no arguments provided
+if (!args.slice(2).length) {
+  program.outputHelp();
+}

package/src/merge/merge-changelog.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import { execSync } from 'child_process';
+
+/**
+ * Simple changelog merger class
+ */
+
+class ChangelogMerger {
+  constructor() {
+    this.content = '';
+  }
+
+  /**
+   * Parse a file with merge conflicts and clean up conflict markers
+   */
+  parseConflict(content) {
+    const lines = content.split('\n');
+    const cleanedLines = [];
+
+    for (const line of lines) {
+      if (line.startsWith('<<<<<<<')) {
+        // Remove conflict start marker
+        continue;
+      } else if (line.startsWith('=======')) {
+        // Replace separator with empty line
+        cleanedLines.push('');
+        continue;
+      } else if (line.startsWith('>>>>>>>')) {
+        // Remove conflict end marker
+        continue;
+      } else {
+        // Keep all other lines
+        cleanedLines.push(line);
+      }
+    }
+
+    this.content = cleanedLines.join('\n');
+  }
+
+  /**
+   * Generate the merged changelog content
+   */
+  generateMerged() {
+    return this.content;
+  }
+}
+
+/**
+ * Changelog merge strategy - removes conflict markers and combines content
+ * @param {string} conflictContent - Content with conflict markers
+ * @returns {string} - Merged content
+ */
+export function mergeChangelog(conflictContent) {
+  const merger = new ChangelogMerger();
+  merger.parseConflict(conflictContent);
+  return merger.generateMerged();
+}
+
+/**
+ * Main function for processing a file with merge conflicts
+ */
+export function mergeChangelogFile(filePath) {
+  try {
+    // Read the file (which contains the conflict markers)
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const result = mergeChangelog(fileContent);
+
+    // Write result back to the same file
+    fs.writeFileSync(filePath, result);
+
+    // Add file to git staging area to mark as resolved
+    try {
+      execSync(`git add ${filePath}`);
+      console.log('📝 File added to git staging area');
+    } catch (error) {
+      console.log(
+        '⚠️  Could not add file to git (may not be in a git repository)',
+      );
+    }
+
+    console.log('Changelog merge completed successfully');
+    return true;
+  } catch (error) {
+    console.error(`Merge failed: ${error.message}`);
+    throw error;
+  }
+}

package/src/merge/merge-package.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import { mergeDriver } from '../lib/merge-driver.js';
+
+/**
+ * Custom merge logic for package.json files
+ * Resolves version conflicts by taking HEAD version
+ * @param {string} headContent - Content from HEAD (current branch)
+ * @param {string} branchContent - Content from incoming branch
+ * @returns {string} - Merged content
+ * @throws {Error} - If conflicts are not version-only
+ */
+function packageMergeLogic(headContent, branchContent) {
+  // Check if this is a version-only conflict
+  if (isVersionOnlyConflict(headContent, branchContent)) {
+    // Take the HEAD version
+    return headContent;
+  } else {
+    // Throw error to keep the conflict unresolved
+    throw new Error('Conflict contains more than just version differences');
+  }
+}
+
+/**
+ * Check if conflict is version-only
+ * @param {string} headContent - Content from HEAD
+ * @param {string} branchContent - Content from branch
+ * @returns {boolean} - True if only version differs
+ */
+function isVersionOnlyConflict(headContent, branchContent) {
+  const headVersionMatch = headContent.match(/"version"\s*:\s*"([^"]+)"/);
+  const branchVersionMatch = branchContent.match(/"version"\s*:\s*"([^"]+)"/);
+
+  if (!headVersionMatch || !branchVersionMatch) {
+    return false;
+  }
+
+  // Remove version lines and check if there's any other content
+  const headWithoutVersion = headContent
+    .replace(/"version"\s*:\s*"[^"]+",?\s*/g, '')
+    .trim();
+  const branchWithoutVersion = branchContent
+    .replace(/"version"\s*:\s*"[^"]+",?\s*/g, '')
+    .trim();
+
+  // If both are empty after removing version, it's version-only
+  // Also handle case where there might be whitespace or comma differences
+  if (!headWithoutVersion && !branchWithoutVersion) {
+    return true;
+  }
+
+  // Additional check: if the only difference is trailing comma or whitespace
+  const normalizeContent = (content) => {
+    return content
+      .replace(/,\s*$/, '') // Remove trailing comma
+      .replace(/\s+/g, ' ') // Normalize whitespace
+      .trim();
+  };
+
+  return (
+    normalizeContent(headWithoutVersion) ===
+    normalizeContent(branchWithoutVersion)
+  );
+}
+
+/**
+ * Main function to merge package.json conflicts using merge-driver
+ * @param {string} filePath - Path to package.json file
+ * @returns {Promise<boolean>} - True if successful
+ */
+export async function mergePackageFile(filePath) {
+  try {
+    // Check if file exists
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    console.log(`🔄 Merging package.json conflicts in: ${filePath}`);
+
+    // Use merge driver with custom package.json merge logic
+    const result = await mergeDriver(filePath, packageMergeLogic);
+
+    // Log results
+    if (result.success) {
+      console.log('✅ Package merge completed successfully');
+      if (result.totalConflicts > 0) {
+        console.log(
+          `   Resolved ${result.resolvedConflicts} version-only conflicts`,
+        );
+      }
+    } else {
+      console.log('⚠️  Package merge partially completed');
+      console.log(
+        `   ${result.resolvedConflicts} of ${result.totalConflicts} conflicts resolved`,
+      );
+      console.log('   Non-version conflicts require manual resolution');
+    }
+
+    return result.success;
+  } catch (error) {
+    console.error(`❌ Merge failed: ${error.message}`);
+    throw error;
+  }
+}
+
+// Default export
+export default mergePackageFile;

package/src/merge/merge-types.js

@@ -0,0 +1,82 @@
+import { mergeDriver } from '../lib/merge-driver.js';
+
+/**
+ * Codegen-specific merge logic for handling balanced braces and removing duplicates
+ * @param {string} headContent - Content from HEAD (current branch)
+ * @param {string} branchContent - Content from the incoming branch
+ * @returns {string} - Merged content
+ * @throws {Error} - If conflicts cannot be automatically merged
+ */
+function codegenMergeLogic(headContent, branchContent) {
+  // Check if braces are balanced in both head and branch content
+  const headOpenBraces = (headContent.match(/\{/g) || []).length;
+  const headCloseBraces = (headContent.match(/\}/g) || []).length;
+  const branchOpenBraces = (branchContent.match(/\{/g) || []).length;
+  const branchCloseBraces = (branchContent.match(/\}/g) || []).length;
+
+  // Check if head content has balanced braces
+  const headHasBraces = headOpenBraces > 0 || headCloseBraces > 0;
+  const headBalanced = headOpenBraces === headCloseBraces;
+
+  // Check if branch content has balanced braces
+  const branchHasBraces = branchOpenBraces > 0 || branchCloseBraces > 0;
+  const branchBalanced = branchOpenBraces === branchCloseBraces;
+
+  // If either has braces and they're not balanced, we can't merge
+  if (
+    (headHasBraces && !headBalanced) ||
+    (branchHasBraces && !branchBalanced)
+  ) {
+    throw new Error('Unbalanced braces detected - cannot merge automatically');
+  }
+
+  // If both have balanced braces, combine them as-is
+  if (headHasBraces && branchHasBraces && headBalanced && branchBalanced) {
+    return headContent + '\n' + branchContent;
+  }
+
+  // If neither has braces, combine and remove duplicates
+  if (!headHasBraces && !branchHasBraces) {
+    const headLines = headContent.split('\n').filter((line) => line);
+    const branchLines = branchContent.split('\n').filter((line) => line);
+
+    // Use Set to remove duplicates while preserving order
+    const uniqueLines = [...new Set([...headLines, ...branchLines])];
+
+    return uniqueLines.join('\n');
+  }
+
+  // Mixed case: one has braces, one doesn't - combine as-is
+  return headContent + '\n' + branchContent;
+}
+
+/**
+ * Main function to merge codegen conflicts in a types file
+ * @param {string} filePath - Path to the file with conflicts
+ * @returns {Promise<Object>} - Result object with merge details
+ */
+export async function mergeTypesFile(filePath) {
+  try {
+    console.log('Starting codegen merge for types file...');
+
+    // Use the merge driver with our custom codegen logic
+    const result = await mergeDriver(filePath, codegenMergeLogic);
+
+    if (result.success) {
+      console.log('✅ Codegen merge completed successfully');
+    } else {
+      console.log('⚠️ Codegen merge completed with unresolved conflicts');
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Codegen merge failed: ${error.message}`);
+    throw error;
+  }
+}
+
+// Export the merge logic function for direct use if needed
+export { codegenMergeLogic };
+
+// Default export
+export default mergeTypesFile;