@dboio/cli 0.4.2 → 0.6.0

package/src/lib/diff.js

@@ -0,0 +1,740 @@
+import chalk from 'chalk';
+import { readFile, writeFile, readdir, access, stat } from 'fs/promises';
+import { join, dirname, basename, extname } from 'path';
+import { parseServerDate, setFileTimestamps } from './timestamps.js';
+import { loadConfig, loadUserInfo } from './config.js';
+import { log } from './logger.js';
+
+// ─── Content Value Resolution ───────────────────────────────────────────────
+
+/**
+ * Resolve a column value that may be base64-encoded.
+ * Server returns large text as: { bytes: N, value: "base64string", encoding: "base64" }
+ */
+export function resolveContentValue(value) {
+  if (value && typeof value === 'object' && !Array.isArray(value)
+      && value.encoding === 'base64') {
+    return typeof value.value === 'string'
+      ? Buffer.from(value.value, 'base64').toString('utf8')
+      : '';
+  }
+  return value !== null && value !== undefined ? String(value) : null;
+}
+
+// ─── File Utilities ─────────────────────────────────────────────────────────
+
+async function fileExists(path) {
+  try { await access(path); return true; } catch { return false; }
+}
+
+/**
+ * Recursively find all .metadata.json files in a directory.
+ */
+export async function findMetadataFiles(dir) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      // Skip hidden dirs, node_modules, .dbo
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      results.push(...await findMetadataFiles(fullPath));
+    } else if (entry.name.endsWith('.metadata.json')) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get the local sync time for a record — the mtime of the metadata.json file.
+ * This represents when the record was last synced from the server.
+ * We intentionally use only the metadata file's mtime, NOT content files,
+ * because local edits to content files would shift the sync point forward
+ * and cause isServerNewer() to miss real server changes.
+ */
+export async function getLocalSyncTime(metaPath) {
+  try {
+    const metaStat = await stat(metaPath);
+    return metaStat.mtime;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if any files (metadata, content, or media) have been locally modified
+ * since the last sync. Compares each file's mtime against the stored _LastUpdated
+ * date (the actual sync baseline set by setFileTimestamps during clone/pull).
+ *
+ * config.ServerTimezone is required to parse the stored _LastUpdated date.
+ * Returns true if any associated file has been modified locally.
+ */
+export async function hasLocalModifications(metaPath, config = {}) {
+  try {
+    const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+
+    // Parse the stored _LastUpdated as the sync baseline
+    const serverTz = config.ServerTimezone;
+    const syncDate = parseServerDate(meta._LastUpdated, serverTz);
+    if (!syncDate) return false;
+    const syncTime = syncDate.getTime();
+
+    // Check if metadata.json itself was edited since last sync
+    const metaStat = await stat(metaPath);
+    if (metaStat.mtime.getTime() > syncTime + 2000) {
+      return true;
+    }
+
+    // Check content files
+    const metaDir = dirname(metaPath);
+    const contentCols = meta._contentColumns || [];
+
+    for (const col of contentCols) {
+      const ref = meta[col];
+      if (ref && String(ref).startsWith('@')) {
+        const contentPath = join(metaDir, String(ref).substring(1));
+        try {
+          const contentStat = await stat(contentPath);
+          if (contentStat.mtime.getTime() > syncTime + 2000) {
+            return true;
+          }
+        } catch { /* missing file */ }
+      }
+    }
+
+    // Check media file reference
+    if (meta._mediaFile && String(meta._mediaFile).startsWith('@')) {
+      const mediaPath = join(metaDir, String(meta._mediaFile).substring(1));
+      try {
+        const mediaStat = await stat(mediaPath);
+        if (mediaStat.mtime.getTime() > syncTime + 2000) {
+          return true;
+        }
+      } catch { /* missing file */ }
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Compare local sync time against server's _LastUpdated.
+ * Returns true if the server record is newer than local files.
+ */
+export function isServerNewer(localSyncTime, serverLastUpdated, config) {
+  if (!serverLastUpdated) return false;
+  if (!localSyncTime) return true;
+
+  const serverTz = config.ServerTimezone;
+  const serverDate = parseServerDate(serverLastUpdated, serverTz);
+  if (!serverDate) return false;
+
+  // Add a small tolerance (2 seconds) for filesystem timestamp precision
+  return serverDate.getTime() > localSyncTime.getTime() + 2000;
+}
+
+// ─── Server Fetching ────────────────────────────────────────────────────────
+
+/**
+ * Fetch a single record from the server by entity and UID.
+ */
+export async function fetchServerRecord(client, entity, uid) {
+  const result = await client.get(`/api/output/entity/${entity}/${uid}`, {
+    '_format': 'json_raw',
+  });
+  const data = result.payload || result.data;
+  const rows = Array.isArray(data) ? data : (data?.Rows || data?.rows || [data]);
+  return rows.length > 0 ? rows[0] : null;
+}
+
+// ─── Diff Algorithm ─────────────────────────────────────────────────────────
+
+/**
+ * Compute a line-based diff between two strings.
+ * Returns array of { type: 'same'|'add'|'remove', line: string }
+ * where 'remove' = in local but not server, 'add' = in server but not local.
+ */
+export function computeLineDiff(localText, serverText) {
+  // Normalize line endings
+  const localLines = (localText || '').replace(/\r\n/g, '\n').split('\n');
+  const serverLines = (serverText || '').replace(/\r\n/g, '\n').split('\n');
+
+  const n = localLines.length;
+  const m = serverLines.length;
+
+  // Build LCS length table (optimized: 2 rows)
+  let prev = new Array(m + 1).fill(0);
+  let curr = new Array(m + 1).fill(0);
+
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      if (localLines[i - 1] === serverLines[j - 1]) {
+        curr[j] = prev[j - 1] + 1;
+      } else {
+        curr[j] = Math.max(prev[j], curr[j - 1]);
+      }
+    }
+    prev = [...curr];
+    curr = new Array(m + 1).fill(0);
+  }
+
+  // Rebuild full table for backtracking (needed for edit script)
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      if (localLines[i - 1] === serverLines[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtrack to build edit script
+  const result = [];
+  let i = n, j = m;
+
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && localLines[i - 1] === serverLines[j - 1]) {
+      result.unshift({ type: 'same', line: localLines[i - 1] });
+      i--; j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: 'add', line: serverLines[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: 'remove', line: localLines[i - 1] });
+      i--;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Format diff entries for terminal display in unified diff style.
+ * Returns array of formatted strings (one per line).
+ */
+export function formatDiff(diffEntries, { contextLines = 3, localLabel = 'local', serverLabel = 'server' } = {}) {
+  const lines = [];
+  lines.push(chalk.dim(`--- ${localLabel}`));
+  lines.push(chalk.dim(`+++ ${serverLabel}`));
+
+  // Group into hunks with context
+  const hunks = groupIntoHunks(diffEntries, contextLines);
+
+  for (const hunk of hunks) {
+    lines.push(chalk.cyan(`@@ -${hunk.localStart},${hunk.localCount} +${hunk.serverStart},${hunk.serverCount} @@`));
+    for (const entry of hunk.entries) {
+      if (entry.type === 'same') {
+        lines.push(chalk.dim(`  ${entry.line}`));
+      } else if (entry.type === 'remove') {
+        lines.push(chalk.red(`- ${entry.line}`));
+      } else if (entry.type === 'add') {
+        lines.push(chalk.green(`+ ${entry.line}`));
+      }
+    }
+  }
+
+  return lines;
+}
+
+/**
+ * Group diff entries into hunks with surrounding context lines.
+ */
+function groupIntoHunks(entries, contextLines) {
+  const hunks = [];
+  const changeIndices = [];
+
+  // Find indices of all changed lines
+  for (let i = 0; i < entries.length; i++) {
+    if (entries[i].type !== 'same') {
+      changeIndices.push(i);
+    }
+  }
+
+  if (changeIndices.length === 0) return [];
+
+  // Group changes that are within (2 * contextLines) of each other
+  let hunkStart = Math.max(0, changeIndices[0] - contextLines);
+  let hunkEnd = Math.min(entries.length - 1, changeIndices[0] + contextLines);
+
+  for (let k = 1; k < changeIndices.length; k++) {
+    const nextStart = Math.max(0, changeIndices[k] - contextLines);
+    if (nextStart <= hunkEnd + 1) {
+      // Merge with current hunk
+      hunkEnd = Math.min(entries.length - 1, changeIndices[k] + contextLines);
+    } else {
+      // Emit current hunk
+      hunks.push(buildHunk(entries, hunkStart, hunkEnd));
+      hunkStart = nextStart;
+      hunkEnd = Math.min(entries.length - 1, changeIndices[k] + contextLines);
+    }
+  }
+
+  // Emit last hunk
+  hunks.push(buildHunk(entries, hunkStart, hunkEnd));
+
+  return hunks;
+}
+
+function buildHunk(entries, start, end) {
+  const hunkEntries = entries.slice(start, end + 1);
+  let localLine = 1, serverLine = 1;
+
+  // Count lines before hunk start
+  for (let i = 0; i < start; i++) {
+    if (entries[i].type === 'same' || entries[i].type === 'remove') localLine++;
+    if (entries[i].type === 'same' || entries[i].type === 'add') serverLine++;
+  }
+
+  let localCount = 0, serverCount = 0;
+  for (const e of hunkEntries) {
+    if (e.type === 'same' || e.type === 'remove') localCount++;
+    if (e.type === 'same' || e.type === 'add') serverCount++;
+  }
+
+  return {
+    localStart: localLine,
+    localCount,
+    serverStart: serverLine,
+    serverCount,
+    entries: hunkEntries,
+  };
+}
+
+// ─── Record Comparison ──────────────────────────────────────────────────────
+
+/**
+ * Compare a local record (metadata.json + content files) against the server.
+ * Returns a DiffResult object.
+ */
+export async function compareRecord(metaPath, client, config) {
+  let localMeta;
+  try {
+    localMeta = JSON.parse(await readFile(metaPath, 'utf8'));
+  } catch (err) {
+    return { error: `Cannot read ${metaPath}: ${err.message}` };
+  }
+
+  const entity = localMeta._entity;
+  const uid = localMeta.UID || localMeta._id;
+
+  if (!entity || !uid) {
+    return { error: `Missing _entity or UID in ${metaPath}` };
+  }
+
+  const serverRecord = await fetchServerRecord(client, entity, uid);
+  if (!serverRecord) {
+    return { error: `Record not found on server: ${entity}/${uid}` };
+  }
+
+  const metaDir = dirname(metaPath);
+  const metaBase = basename(metaPath, '.metadata.json');
+  const contentCols = localMeta._contentColumns || [];
+  const fieldDiffs = [];
+
+  // Compare content file columns
+  for (const col of contentCols) {
+    const localRef = localMeta[col];
+    if (!localRef || !String(localRef).startsWith('@')) continue;
+
+    const localFilePath = join(metaDir, String(localRef).substring(1));
+    let localContent = '';
+    try {
+      localContent = await readFile(localFilePath, 'utf8');
+    } catch {
+      localContent = ''; // File missing locally
+    }
+
+    const serverValue = resolveContentValue(serverRecord[col]);
+    if (serverValue === null) continue;
+
+    if (localContent !== serverValue) {
+      const diff = computeLineDiff(localContent, serverValue);
+      fieldDiffs.push({
+        column: col,
+        isContentFile: true,
+        localValue: localContent,
+        serverValue,
+        localFilePath,
+        diff,
+      });
+    }
+  }
+
+  // Compare metadata fields (non-content, non-system)
+  const skipFields = new Set(['_entity', '_contentColumns', '_mediaFile', 'children']);
+  for (const [key, serverVal] of Object.entries(serverRecord)) {
+    if (skipFields.has(key)) continue;
+    if (contentCols.includes(key)) continue; // Already handled above
+
+    const localVal = localMeta[key];
+    const serverStr = serverVal !== null && serverVal !== undefined ? String(serverVal) : '';
+    const localStr = localVal !== null && localVal !== undefined ? String(localVal) : '';
+
+    if (serverStr !== localStr) {
+      fieldDiffs.push({
+        column: key,
+        isContentFile: false,
+        localValue: localStr,
+        serverValue: serverStr,
+        localFilePath: null,
+        diff: null, // Single-value diff, not line-based
+      });
+    }
+  }
+
+  // Check for fields in local but not on server
+  for (const [key, localVal] of Object.entries(localMeta)) {
+    if (skipFields.has(key)) continue;
+    if (contentCols.includes(key)) continue;
+    if (key in serverRecord) continue;
+
+    const localStr = localVal !== null && localVal !== undefined ? String(localVal) : '';
+    if (localStr) {
+      fieldDiffs.push({
+        column: key,
+        isContentFile: false,
+        localValue: localStr,
+        serverValue: '',
+        localFilePath: null,
+        diff: null,
+      });
+    }
+  }
+
+  // Timestamp info
+  const serverTz = config.ServerTimezone;
+  const localSyncTime = await getLocalSyncTime(metaPath);
+  const serverDate = parseServerDate(serverRecord._LastUpdated, serverTz);
+  const userInfo = await loadUserInfo();
+  const updatedByUserId = serverRecord._LastUpdatedUserID || null;
+
+  return {
+    recordName: metaBase,
+    entity,
+    uid,
+    metaPath,
+    hasChanges: fieldDiffs.length > 0,
+    serverRecord,
+    localMeta,
+    fieldDiffs,
+    timestampInfo: {
+      serverLastUpdated: serverRecord._LastUpdated,
+      localLastUpdated: localMeta._LastUpdated,
+      localSyncTime,
+      serverDate,
+      updatedByUserId,
+      isOwnChange: !!(userInfo.userId && String(updatedByUserId) === String(userInfo.userId)),
+    },
+  };
+}
+
+// ─── Apply Changes ──────────────────────────────────────────────────────────
+
+/**
+ * Apply accepted server changes to local files.
+ * acceptedFields is a Set of column names to update.
+ * Updates content files, metadata.json, and sets mtime on both.
+ */
+export async function applyServerChanges(diffResult, acceptedFields, config) {
+  const { metaPath, serverRecord, localMeta, fieldDiffs } = diffResult;
+  const metaDir = dirname(metaPath);
+  const contentCols = new Set(localMeta._contentColumns || []);
+  let updatedMeta = { ...localMeta };
+  const filesToTimestamp = [metaPath];
+
+  for (const fd of fieldDiffs) {
+    if (!acceptedFields.has(fd.column)) continue;
+
+    if (fd.isContentFile && fd.localFilePath) {
+      // Write server content to local file
+      await writeFile(fd.localFilePath, fd.serverValue);
+      log.success(`Updated ${fd.localFilePath}`);
+      filesToTimestamp.push(fd.localFilePath);
+    }
+
+    if (!fd.isContentFile) {
+      // Update metadata field
+      if (fd.serverValue === '') {
+        delete updatedMeta[fd.column];
+      } else {
+        updatedMeta[fd.column] = serverRecord[fd.column];
+      }
+    }
+  }
+
+  // Always update _LastUpdated in metadata to server value
+  if (serverRecord._LastUpdated) {
+    updatedMeta._LastUpdated = serverRecord._LastUpdated;
+  }
+  if (serverRecord._CreatedOn) {
+    updatedMeta._CreatedOn = serverRecord._CreatedOn;
+  }
+  if (serverRecord._LastUpdatedUserID) {
+    updatedMeta._LastUpdatedUserID = serverRecord._LastUpdatedUserID;
+  }
+
+  // Write updated metadata
+  await writeFile(metaPath, JSON.stringify(updatedMeta, null, 2) + '\n');
+
+  // Set mtime on all affected files to server's _LastUpdated
+  const serverTz = config.ServerTimezone;
+  if (serverTz && serverRecord._LastUpdated) {
+    for (const filePath of filesToTimestamp) {
+      try {
+        await setFileTimestamps(filePath, serverRecord._CreatedOn, serverRecord._LastUpdated, serverTz);
+      } catch { /* non-critical */ }
+    }
+  }
+}
+
+// ─── Change Detection Prompt ────────────────────────────────────────────────
+
+/**
+ * Build the change detection message describing who changed the file.
+ */
+function buildChangeMessage(recordName, serverRecord, config) {
+  const userInfo = loadUserInfoSync();
+  const updatedBy = serverRecord._LastUpdatedUserID;
+
+  if (updatedBy && userInfo && String(updatedBy) === String(userInfo.userId)) {
+    return `"${recordName}" was updated on server by you (from another session)`;
+  } else if (updatedBy) {
+    return `"${recordName}" was updated on server by user ${updatedBy}`;
+  }
+  return `"${recordName}" has updates newer than your local version`;
+}
+
+// Sync version for message building (cached)
+let _cachedUserInfo = null;
+function loadUserInfoSync() {
+  return _cachedUserInfo;
+}
+
+/**
+ * Prompt the user when a record has changed.
+ * options.localIsNewer: when true, the local file has modifications not on server.
+ * Returns: 'overwrite' | 'compare' | 'skip' | 'overwrite_all' | 'skip_all'
+ */
+export async function promptChangeDetection(recordName, serverRecord, config, options = {}) {
+  const localIsNewer = options.localIsNewer || false;
+
+  // Cache user info for message building
+  _cachedUserInfo = await loadUserInfo();
+
+  const message = localIsNewer
+    ? `"${recordName}" has local changes not on the server`
+    : buildChangeMessage(recordName, serverRecord, config);
+
+  const inquirer = (await import('inquirer')).default;
+
+  const choices = localIsNewer
+    ? [
+        { name: 'Restore server version (discard local changes)', value: 'overwrite' },
+        { name: 'Compare differences (dbo diff)', value: 'compare' },
+        { name: 'Keep local changes', value: 'skip' },
+        { name: 'Restore all to server version', value: 'overwrite_all' },
+        { name: 'Keep all local changes', value: 'skip_all' },
+      ]
+    : [
+        { name: 'Overwrite local file with server version', value: 'overwrite' },
+        { name: 'Compare differences (dbo diff)', value: 'compare' },
+        { name: 'Skip this file', value: 'skip' },
+        { name: 'Overwrite this and all remaining changed files', value: 'overwrite_all' },
+        { name: 'Skip all remaining changed files', value: 'skip_all' },
+      ];
+
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message,
+    choices,
+  }]);
+
+  return action;
+}
+
+// ─── Inline Diff & Merge ───────────────────────────────────────────────────
+
+/**
+ * Run an inline diff and merge flow during pull/clone.
+ * Uses in-memory server data (no re-fetch).
+ *
+ * options.localIsNewer: when true, the local file is the newer version.
+ *   - Diff direction flips: green = local (newer), red = server (older)
+ *   - "Accept" means keep the newer (local) version
+ *   - "Skip" means revert to server version
+ *   When false (default): green = server (newer), red = local (older)
+ *   - "Accept" means take server version
+ *   - "Skip" means keep local version
+ *
+ * Returns { applied: Set<string>, skipped: boolean }
+ */
+export async function inlineDiffAndMerge(serverRow, metaPath, config, options = {}) {
+  const localIsNewer = options.localIsNewer || false;
+
+  let localMeta;
+  try {
+    localMeta = JSON.parse(await readFile(metaPath, 'utf8'));
+  } catch {
+    return { applied: new Set(), skipped: true };
+  }
+
+  const metaDir = dirname(metaPath);
+  const metaBase = basename(metaPath, '.metadata.json');
+  const contentCols = localMeta._contentColumns || [];
+  const fieldDiffs = [];
+
+  // Compare content columns
+  for (const col of contentCols) {
+    const localRef = localMeta[col];
+    if (!localRef || !String(localRef).startsWith('@')) continue;
+
+    const localFilePath = join(metaDir, String(localRef).substring(1));
+    let localContent = '';
+    try {
+      localContent = await readFile(localFilePath, 'utf8');
+    } catch {
+      localContent = '';
+    }
+
+    const serverValue = resolveContentValue(serverRow[col]);
+    if (serverValue === null) continue;
+
+    if (localContent !== serverValue) {
+      // Diff direction: green (+) = newer, red (-) = older
+      const diff = localIsNewer
+        ? computeLineDiff(serverValue, localContent)   // green = local (newer)
+        : computeLineDiff(localContent, serverValue);  // green = server (newer)
+      fieldDiffs.push({
+        column: col,
+        isContentFile: true,
+        localValue: localContent,
+        serverValue,
+        localFilePath,
+        diff,
+      });
+    }
+  }
+
+  // Compare metadata fields
+  const skipFields = new Set(['_entity', '_contentColumns', '_mediaFile', 'children']);
+  for (const [key, serverVal] of Object.entries(serverRow)) {
+    if (skipFields.has(key)) continue;
+    if (contentCols.includes(key)) continue;
+
+    const localVal = localMeta[key];
+    const serverStr = serverVal !== null && serverVal !== undefined ? String(serverVal) : '';
+    const localStr = localVal !== null && localVal !== undefined ? String(localVal) : '';
+
+    if (serverStr !== localStr) {
+      fieldDiffs.push({
+        column: key,
+        isContentFile: false,
+        localValue: localStr,
+        serverValue: serverStr,
+        localFilePath: null,
+        diff: null,
+      });
+    }
+  }
+
+  if (fieldDiffs.length === 0) {
+    log.info(`No differences found for "${metaBase}".`);
+    return { applied: new Set(), skipped: true };
+  }
+
+  // Display and prompt per field
+  const accepted = new Set();
+  let bulkAction = null;
+  const inquirer = (await import('inquirer')).default;
+
+  // Labels and prompts depend on which side is newer
+  const newerLabel = localIsNewer ? 'local' : 'server';
+  const olderLabel = localIsNewer ? 'server' : 'local';
+
+  for (const fd of fieldDiffs) {
+    if (bulkAction === 'accept_all') {
+      accepted.add(fd.column);
+      continue;
+    }
+    if (bulkAction === 'skip_all') {
+      continue;
+    }
+
+    // Display the diff — green (+) is always the newer side
+    log.plain('');
+    if (fd.isContentFile && fd.diff) {
+      log.label('Field', `${fd.column} (${fd.localFilePath})`);
+      const formatted = formatDiff(fd.diff, {
+        localLabel: localIsNewer
+          ? `${olderLabel}: ${metaBase}`
+          : `${olderLabel}: ${fd.localFilePath}`,
+        serverLabel: localIsNewer
+          ? `${newerLabel}: ${fd.localFilePath}`
+          : `${newerLabel}: ${metaBase}`,
+      });
+      for (const line of formatted) log.plain(line);
+    } else {
+      log.label('Field', fd.column);
+      // Red (-) = older, Green (+) = newer
+      const olderValue = localIsNewer ? fd.serverValue : fd.localValue;
+      const newerValue = localIsNewer ? fd.localValue : fd.serverValue;
+      if (olderValue) log.plain(chalk.red(`- ${olderValue}`));
+      if (newerValue) log.plain(chalk.green(`+ ${newerValue}`));
+    }
+
+    const promptMessage = localIsNewer
+      ? `Keep local change for "${fd.column}"?`
+      : `Accept server change for "${fd.column}"?`;
+
+    const { action } = await inquirer.prompt([{
+      type: 'list',
+      name: 'action',
+      message: promptMessage,
+      choices: [
+        { name: `Accept (keep ${newerLabel} version)`, value: 'accept' },
+        { name: `Skip (keep ${olderLabel} version)`, value: 'skip' },
+        { name: `Accept all remaining changes`, value: 'accept_all' },
+        { name: `Skip all remaining changes`, value: 'skip_all' },
+      ],
+    }]);
+
+    if (action === 'accept' || action === 'accept_all') {
+      accepted.add(fd.column);
+    }
+    if (action === 'accept_all' || action === 'skip_all') {
+      bulkAction = action;
+    }
+  }
+
+  // Apply changes based on direction
+  if (localIsNewer) {
+    // "Accepted" = keep local (no-op). "Skipped" = revert to server.
+    const allColumns = new Set(fieldDiffs.map(fd => fd.column));
+    const revertToServer = new Set([...allColumns].filter(c => !accepted.has(c)));
+    if (revertToServer.size > 0) {
+      const diffResult = { metaPath, serverRecord: serverRow, localMeta, fieldDiffs };
+      await applyServerChanges(diffResult, revertToServer, config);
+      log.info(`Reverted ${revertToServer.size} field(s) to server version for "${metaBase}"`);
+    }
+    if (accepted.size > 0) {
+      log.info(`Kept ${accepted.size} local change(s) for "${metaBase}"`);
+    }
+  } else {
+    // "Accepted" = take server version. "Skipped" = keep local.
+    if (accepted.size > 0) {
+      const diffResult = { metaPath, serverRecord: serverRow, localMeta, fieldDiffs };
+      await applyServerChanges(diffResult, accepted, config);
+      log.info(`Applied ${accepted.size} change(s) for "${metaBase}"`);
+    }
+  }
+
+  return { applied: accepted, skipped: accepted.size === 0 };
+}