@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/bin/lib/merge-conflicts.cjs

@@ -0,0 +1,654 @@
+/**
+ * Merge Conflicts — Conflict detection, context assembly, classification, and resolution recording
+ *
+ * Provides CLI commands for the merge-conflicts subcommand group:
+ * - detect: parse failed merge state, return conflicted files grouped by repo
+ * - context: assemble resolution context for a specific file
+ * - resolved: record resolution outcome to RESOLUTIONS.md
+ * - summary: aggregate all resolutions into a merge-level report
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execGit, safeReadFile, loadConfig, output, error } = require('./core.cjs');
+const { parseReposMd } = require('./repos.cjs');
+const { extractFrontmatter } = require('./frontmatter.cjs');
+
+// ─── Conflict Hunk Parsing ──────────────────────────────────────────────────
+
+/**
+ * Parse conflict hunks from file content containing merge conflict markers.
+ * Each hunk is bounded by <<<<<<< and >>>>>>>, with ======= separating ours/theirs.
+ *
+ * @param {string} content - File content with conflict markers
+ * @returns {Array<{start_line: number, end_line: number, ours: string, theirs: string}>}
+ */
+function parseConflictHunks(content) {
+  const lines = content.split('\n');
+  const hunks = [];
+  let inConflict = false;
+  let inOurs = false;
+  let startLine = 0;
+  let oursLines = [];
+  let theirsLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^<{7}/.test(line)) {
+      inConflict = true;
+      inOurs = true;
+      startLine = i + 1; // 1-based
+      oursLines = [];
+      theirsLines = [];
+    } else if (inConflict && /^={7}/.test(line)) {
+      inOurs = false;
+    } else if (inConflict && /^>{7}/.test(line)) {
+      hunks.push({
+        start_line: startLine,
+        end_line: i + 1, // 1-based
+        ours: oursLines.join('\n'),
+        theirs: theirsLines.join('\n'),
+      });
+      inConflict = false;
+      inOurs = false;
+    } else if (inConflict) {
+      if (inOurs) {
+        oursLines.push(line);
+      } else {
+        theirsLines.push(line);
+      }
+    }
+  }
+
+  return hunks;
+}
+
+// ─── Classification Logic ───────────────────────────────────────────────────
+
+/**
+ * Structural pattern detection for code lines.
+ * Matches function declarations, class declarations, imports, exports,
+ * require statements, and scope-defining punctuation.
+ *
+ * @param {string} line - Single line of code
+ * @returns {boolean}
+ */
+function isStructuralLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+
+  const structuralPatterns = [
+    /^\s*function\s+\w+/,
+    /^\s*class\s+\w+/,
+    /^\s*module\.exports/,
+    /^\s*require\s*\(/,
+    /^\s*import\s+/,
+    /^\s*export\s+/,
+    /^\s*const\s+\w+\s*=\s*require\s*\(/,
+    /^\s*[{}()[\]]\s*$/,
+    /^\s*[{}()[\]],?\s*$/,
+  ];
+
+  return structuralPatterns.some(p => p.test(line));
+}
+
+/**
+ * Check if every non-empty line of the shorter side appears in the longer side.
+ *
+ * @param {string[]} shorter - Lines from shorter side
+ * @param {string[]} longer - Lines from longer side
+ * @returns {boolean}
+ */
+function isSupersetOf(shorter, longer) {
+  const longerSet = new Set(longer.map(l => l.trim()).filter(l => l));
+  return shorter.filter(l => l.trim()).every(l => longerSet.has(l.trim()));
+}
+
+/**
+ * Classify conflict hunks from a file's content.
+ *
+ * Pure function (no I/O) that takes a file's content (with conflict markers)
+ * and optional plan context (task descriptions that touched this file),
+ * and returns classified hunks.
+ *
+ * Classification types:
+ * - ADDITIVE: One side adds new code the other doesn't have
+ * - DELETION: One side removes lines the other keeps
+ * - DIVERGENT: Both sides modify the same lines differently
+ * - STRUCTURAL: Changes to function signatures, imports, exports, scope
+ *
+ * @param {string} fileContent - File content with conflict markers
+ * @param {Array<{task_name: string, action_excerpt: string}>|null} planContext - Optional plan context
+ * @returns {Array<{start_line: number, end_line: number, ours: string, theirs: string, type: string, confidence: string, ambiguous: boolean, reasoning: string}>}
+ */
+function classifyConflictHunks(fileContent, planContext) {
+  const hunks = parseConflictHunks(fileContent);
+
+  return hunks.map(hunk => {
+    const oursLines = hunk.ours.split('\n').filter(l => l.trim());
+    const theirsLines = hunk.theirs.split('\n').filter(l => l.trim());
+    const oursEmpty = oursLines.length === 0;
+    const theirsEmpty = theirsLines.length === 0;
+
+    let type = 'DIVERGENT';
+    let confidence = 'LOW';
+    let ambiguous = false;
+    let reasoning = '';
+
+    // Check STRUCTURAL first — both sides have structural patterns
+    const oursStructural = oursLines.filter(isStructuralLine);
+    const theirsStructural = theirsLines.filter(isStructuralLine);
+
+    if (oursStructural.length > 0 && theirsStructural.length > 0) {
+      type = 'STRUCTURAL';
+      confidence = 'HIGH';
+      reasoning = 'Both sides modify structural elements (functions, imports, exports, or scope)';
+    } else if (oursStructural.length > 0 || theirsStructural.length > 0) {
+      // Only one side has structural changes
+      const structSide = oursStructural.length > 0 ? 'ours' : 'theirs';
+      type = 'STRUCTURAL';
+      confidence = 'MEDIUM';
+      reasoning = `Structural patterns detected on ${structSide} side`;
+    }
+    // Check ADDITIVE
+    else if (oursEmpty || theirsEmpty) {
+      if (oursEmpty && !theirsEmpty) {
+        type = 'ADDITIVE';
+        confidence = 'HIGH';
+        reasoning = 'Ours side is empty — theirs adds new content';
+      } else if (theirsEmpty && !oursEmpty) {
+        // Could be DELETION (theirs removes content) or ADDITIVE (ours adds content)
+        // Without merge-base context, classify as DELETION
+        type = 'DELETION';
+        confidence = 'HIGH';
+        reasoning = 'Theirs side is empty — content was removed on theirs branch';
+      }
+    }
+    // Check superset patterns
+    else if (isSupersetOf(oursLines, theirsLines)) {
+      type = 'ADDITIVE';
+      confidence = 'MEDIUM';
+      reasoning = 'Theirs is a superset of ours — theirs adds additional content';
+    } else if (isSupersetOf(theirsLines, oursLines)) {
+      type = 'ADDITIVE';
+      confidence = 'MEDIUM';
+      reasoning = 'Ours is a superset of theirs — ours adds additional content';
+    }
+    // Default: DIVERGENT
+    else {
+      type = 'DIVERGENT';
+      confidence = 'LOW';
+      reasoning = 'Both sides have content, neither is a superset of the other';
+      ambiguous = true;
+    }
+
+    // Enhance classification with plan context if available
+    if (planContext && Array.isArray(planContext) && planContext.length > 0) {
+      const contextText = planContext.map(c => (c.task_name || '') + ' ' + (c.action_excerpt || '')).join(' ').toLowerCase();
+
+      if (type === 'ADDITIVE' && (contextText.includes('add') || contextText.includes('new') || contextText.includes('create'))) {
+        confidence = 'HIGH';
+        reasoning += '. Plan context confirms additive intent';
+      }
+
+      if (type === 'DIVERGENT' && contextText.length > 0) {
+        confidence = 'MEDIUM';
+        reasoning += '. Plan context available for both changes';
+        ambiguous = true;
+      }
+    }
+
+    return {
+      start_line: hunk.start_line,
+      end_line: hunk.end_line,
+      ours: hunk.ours,
+      theirs: hunk.theirs,
+      type,
+      confidence,
+      ambiguous,
+      reasoning,
+    };
+  });
+}
+
+// ─── Conflict Detection ─────────────────────────────────────────────────────
+
+/**
+ * Detect conflicted files after a failed merge.
+ * Parses git merge state and returns conflicted files grouped by repo
+ * with rich metadata.
+ *
+ * @param {string} cwd - Working directory
+ * @param {string|null} phaseDir - Optional phase directory for context
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdMergeConflictsDetect(cwd, phaseDir, raw) {
+  const timestamp = new Date().toISOString();
+
+  // Get conflicted files
+  const diffResult = execGit(cwd, ['diff', '--name-only', '--diff-filter=U']);
+  const conflictedFiles = diffResult.exitCode === 0 && diffResult.stdout
+    ? diffResult.stdout.split('\n').filter(f => f.trim())
+    : [];
+
+  if (conflictedFiles.length === 0) {
+    output({
+      conflicted: false,
+      files: [],
+      repos: {},
+      metadata: {
+        timestamp,
+        branch: null,
+        merge_head: null,
+        head_sha: null,
+        merge_base: null,
+        command_version: '1.0',
+      },
+    }, raw);
+    return;
+  }
+
+  // Get metadata
+  const branchResult = execGit(cwd, ['branch', '--show-current']);
+  const branch = branchResult.exitCode === 0 ? branchResult.stdout : null;
+
+  const mergeHeadResult = execGit(cwd, ['rev-parse', 'MERGE_HEAD']);
+  const mergeHead = mergeHeadResult.exitCode === 0 ? mergeHeadResult.stdout : null;
+
+  const headResult = execGit(cwd, ['rev-parse', 'HEAD']);
+  const headSha = headResult.exitCode === 0 ? headResult.stdout : null;
+
+  let mergeBase = null;
+  if (mergeHead) {
+    const baseResult = execGit(cwd, ['merge-base', 'HEAD', 'MERGE_HEAD']);
+    mergeBase = baseResult.exitCode === 0 ? baseResult.stdout : null;
+  }
+
+  // Parse REPOS.md for grouping
+  const reposData = parseReposMd(cwd);
+  const repos = reposData ? reposData.repos : [];
+
+  // Group files by repo
+  const grouped = {};
+
+  for (const filePath of conflictedFiles) {
+    let repoName = '_product';
+
+    // Check which repo owns this file by prefix matching
+    for (const repo of repos) {
+      const repoPath = repo.path.replace(/^\.\//, '').replace(/^\.\.\//, '');
+      if (filePath.startsWith(repoPath + '/')) {
+        repoName = repo.name;
+        break;
+      }
+    }
+
+    if (!grouped[repoName]) {
+      grouped[repoName] = { files: [], count: 0 };
+    }
+
+    // Count conflict markers in the file
+    let conflictMarkers = 0;
+    const fullPath = path.join(cwd, filePath);
+    const content = safeReadFile(fullPath);
+    if (content) {
+      const lines = content.split('\n');
+      conflictMarkers = lines.filter(l => /^<{7}/.test(l)).length;
+    }
+
+    // Determine path relative to repo
+    let relPath = filePath;
+    if (repoName !== '_product') {
+      const repo = repos.find(r => r.name === repoName);
+      if (repo) {
+        const repoPath = repo.path.replace(/^\.\//, '').replace(/^\.\.\//, '');
+        relPath = filePath.slice(repoPath.length + 1);
+      }
+    }
+
+    grouped[repoName].files.push({
+      path: relPath,
+      full_path: filePath,
+      conflict_markers: conflictMarkers,
+    });
+    grouped[repoName].count++;
+  }
+
+  output({
+    conflicted: true,
+    file_count: conflictedFiles.length,
+    repos: grouped,
+    metadata: {
+      timestamp,
+      branch,
+      merge_head: mergeHead,
+      head_sha: headSha,
+      merge_base: mergeBase,
+      command_version: '1.0',
+    },
+  }, raw);
+}
+
+// ─── Context Assembly ───────────────────────────────────────────────────────
+
+/**
+ * Assemble resolution context for a specific conflicted file.
+ * Gathers conflict hunks, plan task matching, SUMMARY context, and branch identification.
+ *
+ * @param {string} cwd - Working directory
+ * @param {string} filePath - Path to conflicted file
+ * @param {string|null} phaseDir - Phase directory for plan/summary context
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdMergeConflictsContext(cwd, filePath, phaseDir, raw) {
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+
+  // Validate file exists and has conflict markers
+  const fileContent = safeReadFile(fullPath);
+  if (!fileContent) {
+    error('File not found: ' + filePath);
+  }
+
+  if (!/^<{7}/m.test(fileContent)) {
+    error('File has no conflict markers: ' + filePath);
+  }
+
+  // Plan task matching
+  let planContext = [];
+  if (phaseDir) {
+    const absPhaseDir = path.isAbsolute(phaseDir) ? phaseDir : path.join(cwd, phaseDir);
+    try {
+      const phaseFiles = fs.readdirSync(absPhaseDir);
+      const planFiles = phaseFiles.filter(f => f.match(/\d+-PLAN\.md$/i) || f === 'PLAN.md');
+
+      for (const planFile of planFiles) {
+        const planContent = safeReadFile(path.join(absPhaseDir, planFile));
+        if (!planContent) continue;
+
+        const fm = extractFrontmatter(planContent);
+        const planNumber = fm.plan || planFile.replace(/-PLAN\.md$/i, '');
+
+        // Search for <files> tags in tasks and match against the conflicted file
+        const taskPattern = /<task\b[^>]*>([\s\S]*?)<\/task>/g;
+        let match;
+        while ((match = taskPattern.exec(planContent)) !== null) {
+          const taskBody = match[1];
+          const nameMatch = taskBody.match(/<name>([\s\S]*?)<\/name>/);
+          const filesMatch = taskBody.match(/<files>([\s\S]*?)<\/files>/);
+          const actionMatch = taskBody.match(/<action>([\s\S]*?)<\/action>/);
+
+          if (filesMatch) {
+            const filesList = filesMatch[1].split(/[\n,]/).map(f => f.trim()).filter(f => f);
+            const normalizedFilePath = filePath.replace(/^\.\//, '');
+
+            if (filesList.some(f => normalizedFilePath.includes(f.replace(/^\.\//, '')) || f.replace(/^\.\//, '').includes(normalizedFilePath))) {
+              const taskName = nameMatch ? nameMatch[1].trim() : 'unnamed';
+              const actionExcerpt = actionMatch ? actionMatch[1].trim().slice(0, 200) : '';
+              planContext.push({
+                plan: planNumber,
+                task_name: taskName,
+                action_excerpt: actionExcerpt,
+              });
+            }
+          }
+        }
+      }
+    } catch {
+      // Phase dir not readable — fall through to git fallback
+    }
+
+    // Fallback: git log commit matching
+    if (planContext.length === 0) {
+      const logResult = execGit(cwd, ['log', '--oneline', '--follow', '-10', '--', filePath]);
+      if (logResult.exitCode === 0 && logResult.stdout) {
+        const commits = logResult.stdout.split('\n').filter(l => l.trim());
+        for (const commit of commits) {
+          const planMatch = commit.match(/(?:feat|fix|test|refactor|chore)\((\d+-\d+)\)/);
+          if (planMatch) {
+            planContext.push({
+              plan: planMatch[1],
+              task_name: commit.replace(/^[a-f0-9]+\s+/, ''),
+              action_excerpt: '',
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // Classify hunks
+  const hunks = classifyConflictHunks(fileContent, planContext.length > 0 ? planContext : null);
+
+  // SUMMARY.md context
+  let summaryContext = [];
+  if (phaseDir) {
+    const absPhaseDir = path.isAbsolute(phaseDir) ? phaseDir : path.join(cwd, phaseDir);
+    try {
+      const phaseFiles = fs.readdirSync(absPhaseDir);
+      const summaryFiles = phaseFiles.filter(f => f.match(/\d+-SUMMARY\.md$/i) || f === 'SUMMARY.md');
+
+      for (const summaryFile of summaryFiles) {
+        const summaryContent = safeReadFile(path.join(absPhaseDir, summaryFile));
+        if (!summaryContent) continue;
+
+        const fm = extractFrontmatter(summaryContent);
+
+        // Check if key-files mention this file
+        const keyFiles = fm['key-files'] || {};
+        const created = keyFiles.created || [];
+        const modified = keyFiles.modified || [];
+        const allKeyFiles = [...(Array.isArray(created) ? created : [created]), ...(Array.isArray(modified) ? modified : [modified])];
+        const normalizedFilePath = filePath.replace(/^\.\//, '');
+
+        if (allKeyFiles.some(f => f && (normalizedFilePath.includes(f.replace(/^\.\//, '')) || f.replace(/^\.\//, '').includes(normalizedFilePath)))) {
+          // Extract accomplishments section
+          const accomplishmentsMatch = summaryContent.match(/## Accomplishments\s*\n([\s\S]*?)(?=\n## |\n---)/);
+          const accomplishments = accomplishmentsMatch ? accomplishmentsMatch[1].trim() : '';
+
+          summaryContext.push({
+            plan: fm.plan || summaryFile.replace(/-SUMMARY\.md$/i, ''),
+            accomplishments,
+          });
+        }
+      }
+    } catch {
+      // Phase dir not readable
+    }
+  }
+
+  // Branch identification
+  const branchResult = execGit(cwd, ['branch', '--show-current']);
+  const oursBranch = branchResult.exitCode === 0 ? branchResult.stdout : null;
+
+  let theirsBranch = null;
+  const mergeHeadResult = execGit(cwd, ['log', '-1', '--format=%D', 'MERGE_HEAD']);
+  if (mergeHeadResult.exitCode === 0 && mergeHeadResult.stdout) {
+    theirsBranch = mergeHeadResult.stdout;
+  }
+
+  // Extract phase numbers from branch names
+  const phasePattern = /(?:dgs|gsd)\/.*phase-(\d+)/;
+  const oursPhase = oursBranch ? (oursBranch.match(phasePattern) || [])[1] || null : null;
+  const theirsPhase = theirsBranch ? (theirsBranch.match(phasePattern) || [])[1] || null : null;
+
+  // Merge base
+  let mergeBase = null;
+  const mergeHeadShaResult = execGit(cwd, ['rev-parse', 'MERGE_HEAD']);
+  if (mergeHeadShaResult.exitCode === 0) {
+    const baseResult = execGit(cwd, ['merge-base', 'HEAD', 'MERGE_HEAD']);
+    mergeBase = baseResult.exitCode === 0 ? baseResult.stdout : null;
+  }
+
+  output({
+    file: filePath,
+    hunks,
+    plan_context: planContext,
+    summary_context: summaryContext,
+    branches: {
+      ours: { name: oursBranch, phase: oursPhase },
+      theirs: { name: theirsBranch, phase: theirsPhase },
+    },
+    metadata: {
+      timestamp: new Date().toISOString(),
+      merge_base: mergeBase,
+    },
+  }, raw);
+}
+
+// ─── Resolution Recording ───────────────────────────────────────────────────
+
+/**
+ * Record a resolution outcome to RESOLUTIONS.md in the phase directory.
+ *
+ * @param {string} cwd - Working directory
+ * @param {string} filePath - Path to the resolved file
+ * @param {string} phaseDir - Phase directory for RESOLUTIONS.md
+ * @param {string} resolution - JSON string with strategy, description, confidence
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdMergeConflictsResolved(cwd, filePath, phaseDir, resolution, raw) {
+  if (!filePath) error('File path required');
+  if (!phaseDir) error('Phase directory required (--phase-dir)');
+  if (!resolution) error('Resolution JSON required (--resolution)');
+
+  // Parse resolution JSON
+  let res;
+  try {
+    res = JSON.parse(resolution);
+  } catch {
+    error('Invalid resolution JSON. Expected: {"strategy":"ours|theirs|manual|combined","description":"...","confidence":"HIGH|MEDIUM|LOW"}');
+  }
+
+  const validStrategies = ['ours', 'theirs', 'manual', 'combined'];
+  if (!res.strategy || !validStrategies.includes(res.strategy)) {
+    error('Invalid strategy. Must be one of: ' + validStrategies.join(', '));
+  }
+
+  const validConfidences = ['HIGH', 'MEDIUM', 'LOW'];
+  if (!res.confidence || !validConfidences.includes(res.confidence)) {
+    error('Invalid confidence. Must be one of: ' + validConfidences.join(', '));
+  }
+
+  // Verify the file no longer has conflict markers
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+  const fileContent = safeReadFile(fullPath);
+  if (fileContent && /^<{7}/m.test(fileContent)) {
+    error('File still has conflict markers. Resolve before recording.');
+  }
+
+  const timestamp = new Date().toISOString();
+  const absPhaseDir = path.isAbsolute(phaseDir) ? phaseDir : path.join(cwd, phaseDir);
+  const resolutionsPath = path.join(absPhaseDir, 'RESOLUTIONS.md');
+
+  // Create or append to RESOLUTIONS.md
+  let existing = safeReadFile(resolutionsPath);
+  if (!existing) {
+    // Extract phase name from directory
+    const phaseName = path.basename(absPhaseDir);
+    existing = `# Merge Conflict Resolutions\n\n**Phase:** ${phaseName}\n**Created:** ${timestamp}\n\n---\n\n`;
+  }
+
+  // Append resolution entry
+  const entry = [
+    `### ${filePath}\n`,
+    `- **Strategy:** ${res.strategy}`,
+    `- **Confidence:** ${res.confidence}`,
+    `- **Description:** ${res.description || 'No description provided'}`,
+    `- **Resolved:** ${timestamp}`,
+    '',
+  ].join('\n');
+
+  const newContent = existing + entry + '\n';
+  fs.writeFileSync(resolutionsPath, newContent, 'utf-8');
+
+  output({
+    recorded: true,
+    file: filePath,
+    resolutions_path: resolutionsPath,
+  }, raw);
+}
+
+// ─── Resolution Summary ─────────────────────────────────────────────────────
+
+/**
+ * Aggregate all per-file resolutions from RESOLUTIONS.md into a merge-level report.
+ *
+ * @param {string} cwd - Working directory
+ * @param {string} phaseDir - Phase directory containing RESOLUTIONS.md
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdMergeConflictsSummary(cwd, phaseDir, raw) {
+  if (!phaseDir) error('Phase directory required (--phase-dir)');
+
+  const absPhaseDir = path.isAbsolute(phaseDir) ? phaseDir : path.join(cwd, phaseDir);
+  const resolutionsPath = path.join(absPhaseDir, 'RESOLUTIONS.md');
+  const content = safeReadFile(resolutionsPath);
+
+  if (!content) {
+    output({ found: false, resolutions: [], summary: null }, raw, '');
+    return;
+  }
+
+  // Parse resolution entries — each is a ### <filepath> section with bullet fields
+  const entries = [];
+  const entryPattern = /### (.+)\n([\s\S]*?)(?=\n### |\n*$)/g;
+  let match;
+
+  while ((match = entryPattern.exec(content)) !== null) {
+    const file = match[1].trim();
+    const body = match[2];
+
+    const strategyMatch = body.match(/\*\*Strategy:\*\*\s*(\w+)/);
+    const confidenceMatch = body.match(/\*\*Confidence:\*\*\s*(\w+)/);
+    const descriptionMatch = body.match(/\*\*Description:\*\*\s*(.+)/);
+    const timestampMatch = body.match(/\*\*Resolved:\*\*\s*(.+)/);
+
+    entries.push({
+      file,
+      strategy: strategyMatch ? strategyMatch[1] : 'unknown',
+      confidence: confidenceMatch ? confidenceMatch[1] : 'unknown',
+      description: descriptionMatch ? descriptionMatch[1].trim() : '',
+      timestamp: timestampMatch ? timestampMatch[1].trim() : '',
+    });
+  }
+
+  // Aggregate
+  const byStrategy = { ours: 0, theirs: 0, manual: 0, combined: 0 };
+  const byConfidence = { HIGH: 0, MEDIUM: 0, LOW: 0 };
+
+  for (const entry of entries) {
+    if (byStrategy[entry.strategy] !== undefined) {
+      byStrategy[entry.strategy]++;
+    }
+    if (byConfidence[entry.confidence] !== undefined) {
+      byConfidence[entry.confidence]++;
+    }
+  }
+
+  output({
+    found: true,
+    total_resolved: entries.length,
+    by_strategy: byStrategy,
+    by_confidence: byConfidence,
+    resolutions: entries.map(e => ({
+      file: e.file,
+      strategy: e.strategy,
+      confidence: e.confidence,
+      timestamp: e.timestamp,
+    })),
+    metadata: {
+      phase_dir: phaseDir,
+      timestamp: new Date().toISOString(),
+    },
+  }, raw);
+}
+
+// ─── Exports ────────────────────────────────────────────────────────────────
+
+module.exports = {
+  cmdMergeConflictsDetect,
+  cmdMergeConflictsContext,
+  cmdMergeConflictsResolved,
+  cmdMergeConflictsSummary,
+  classifyConflictHunks,
+};