@deneb-ui/cli 2.0.21 → 2.0.23

package/src/arc/fivora-contract.cjs

@@ -0,0 +1,521 @@
+'use strict';
+
+/**
+ * Faithful port of the Fivora strict visual-editing contract rules that the
+ * platform ingest pipeline applies (backend/src/common/template-visual-edit-contract.ts).
+ *
+ * ARC self-validates against these rules so a converted project is rejected
+ * locally rather than at upload time.
+ */
+
+const MARKER_ATTRIBUTE_TO_KIND = {
+  'data-preview-field-path': 'field',
+  'data-preview-list-path': 'list',
+  'data-preview-item-path': 'item',
+  'data-preview-page-key': 'page',
+};
+
+const MARKER_ATTRIBUTE_PATTERN =
+  /\b(data-preview-(?:field-path|list-path|item-path|page-key))\s*=\s*(?:"([^"]*)"|'([^']*)'|\{\s*`([\s\S]*?)`\s*\}|\{\s*"([^"]*)"\s*\}|\{\s*'([^']*)'\s*\})/g;
+
+const MARKER_ATTRIBUTE_OCCURRENCE_PATTERN =
+  /\b(data-preview-(?:field-path|list-path|item-path|page-key))\s*=/g;
+
+const PATH_SEGMENT_PATTERN = String.raw`[^.[\]\s]+`;
+const CANONICAL_PATH_PATTERN = new RegExp(
+  String.raw`^${PATH_SEGMENT_PATTERN}(?:\[(?:\d+|\*)\])*(?:\.${PATH_SEGMENT_PATTERN}(?:\[(?:\d+|\*)\])*)*$`
+);
+
+// Mirrors BROAD_CONTENT_CONTAINERS in the platform contract.
+const BROAD_CONTENT_CONTAINERS = new Set([
+  'html', 'body', 'main', 'header', 'footer', 'nav', 'section', 'article',
+  'aside', 'form', 'div', 'ul', 'ol', 'table', 'thead', 'tbody', 'tfoot', 'tr',
+]);
+
+const PRIMITIVE_TYPES = new Set([
+  'text', 'textarea', 'email', 'tel', 'url', 'image', 'number', 'boolean', 'select',
+]);
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function appendPath(basePath, key) {
+  return basePath ? `${basePath}.${key}` : key;
+}
+
+function wildcardPath(path) {
+  return String(path).replace(/\[\d+\]/g, '[*]');
+}
+
+function canonicalizeMarkerPath(value) {
+  const normalized = String(value ?? '')
+    .trim()
+    .replace(/\[\s*\$\{[^}]+\}\s*\]/g, '[*]')
+    .replace(/\[\s+/g, '[')
+    .replace(/\s+\]/g, ']');
+  return CANONICAL_PATH_PATTERN.test(normalized) ? normalized : null;
+}
+
+function pathsOverlap(left, right) {
+  return wildcardPath(left) === wildcardPath(right);
+}
+
+function isControlOnly(path, controlOnlyPaths) {
+  return (controlOnlyPaths || []).some((controlPath) =>
+    controlPath.includes('[*]') ? wildcardPath(path) === controlPath : path === controlPath
+  );
+}
+
+/** Port of walkContentValue: derives every editable path implied by site-data content. */
+function enumerateContentPaths(content) {
+  const inventory = {
+    fieldPatterns: new Set(),
+    concreteFields: new Set(),
+    listPatterns: new Set(),
+    concreteLists: new Set(),
+    itemPatterns: new Set(),
+    concreteItems: new Set(),
+  };
+
+  function walk(value, path) {
+    if (Array.isArray(value)) {
+      const listPattern = wildcardPath(path);
+      inventory.listPatterns.add(listPattern);
+      inventory.concreteLists.add(path);
+      inventory.itemPatterns.add(`${listPattern}[*]`);
+      value.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        inventory.concreteItems.add(itemPath);
+        if (Array.isArray(item) || isPlainObject(item)) {
+          walk(item, itemPath);
+        } else {
+          inventory.fieldPatterns.add(wildcardPath(itemPath));
+          inventory.concreteFields.add(itemPath);
+        }
+      });
+      return;
+    }
+    if (isPlainObject(value)) {
+      for (const [key, child] of Object.entries(value)) {
+        walk(child, appendPath(path, key));
+      }
+      return;
+    }
+    inventory.fieldPatterns.add(wildcardPath(path));
+    inventory.concreteFields.add(path);
+  }
+
+  if (isPlainObject(content)) {
+    for (const [key, value] of Object.entries(content)) {
+      walk(value, key);
+    }
+  }
+
+  return inventory;
+}
+
+/** Port of walkSchemaNode: derives editable paths implied by editorSchema. */
+function enumerateSchemaPaths(editorSchema) {
+  const fieldPatterns = new Set();
+  const listPatterns = new Set();
+  const itemPatterns = new Set();
+
+  function walk(path, node) {
+    if (!node) return;
+    if (node.type === 'object') {
+      for (const field of node.fields || []) {
+        walk(appendPath(path, field.key), field);
+      }
+      return;
+    }
+    if (node.type === 'list') {
+      const listPattern = wildcardPath(path);
+      const itemPattern = `${listPattern}[*]`;
+      listPatterns.add(listPattern);
+      itemPatterns.add(itemPattern);
+      if (node.itemField) fieldPatterns.add(itemPattern);
+      for (const field of node.fields || []) {
+        walk(appendPath(itemPattern, field.key), field);
+      }
+      return;
+    }
+    fieldPatterns.add(wildcardPath(path));
+  }
+
+  for (const section of editorSchema?.sections || []) {
+    walk(section.path, section);
+  }
+
+  return { fieldPatterns, listPatterns, itemPatterns };
+}
+
+/** Port of extractTemplateVisualEditMarkers for a single artifact. */
+function extractMarkers(code, filePath = '') {
+  const markers = [];
+  const unparseable = [];
+  const parsedOffsets = new Set();
+
+  MARKER_ATTRIBUTE_PATTERN.lastIndex = 0;
+  for (const match of String(code).matchAll(MARKER_ATTRIBUTE_PATTERN)) {
+    const attributeName = match[1];
+    const rawValue = match[2] ?? match[3] ?? match[4] ?? match[5] ?? match[6] ?? '';
+    const offset = match.index ?? 0;
+    parsedOffsets.add(offset);
+    markers.push({
+      kind: MARKER_ATTRIBUTE_TO_KIND[attributeName],
+      value: String(rawValue).trim(),
+      filePath,
+      offset,
+      line: lineNumberAt(code, offset),
+    });
+  }
+
+  MARKER_ATTRIBUTE_OCCURRENCE_PATTERN.lastIndex = 0;
+  for (const match of String(code).matchAll(MARKER_ATTRIBUTE_OCCURRENCE_PATTERN)) {
+    const offset = match.index ?? 0;
+    if (!parsedOffsets.has(offset)) {
+      unparseable.push(
+        `${filePath}:${lineNumberAt(code, offset)} ${match[1]} must use a literal string or a JSX template literal.`
+      );
+    }
+  }
+
+  return { markers, unparseable };
+}
+
+function lineNumberAt(content, offset) {
+  let line = 1;
+  for (let index = 0; index < offset && index < content.length; index += 1) {
+    if (content.charCodeAt(index) === 10) line += 1;
+  }
+  return line;
+}
+
+/**
+ * Scans JSX source for marker placement violations that the platform detects in
+ * exported HTML. Source scanning cannot see the final DOM, but a violation in
+ * source deterministically produces the same violation in the export.
+ */
+function auditMarkerPlacement(code, filePath) {
+  const errors = [];
+  const tagPattern = /<\s*([a-zA-Z][a-zA-Z0-9.:-]*)((?:[^<>{}]|\{[^{}]*\})*?)(\/?)>/g;
+
+  for (const match of String(code).matchAll(tagPattern)) {
+    const tag = match[1];
+    const attrs = match[2] || '';
+    const offset = match.index ?? 0;
+    const line = lineNumberAt(code, offset);
+    const lowerTag = tag.toLowerCase();
+
+    const hasField = /\bdata-preview-field-path\s*=/.test(attrs);
+    const hasList = /\bdata-preview-list-path\s*=/.test(attrs);
+    const hasItem = /\bdata-preview-item-path\s*=/.test(attrs);
+    const staticMatch = attrs.match(/\bdata-preview-static\s*=\s*(?:"([^"]*)"|'([^']*)')/);
+    const hasStatic = /\bdata-preview-static\b/.test(attrs);
+
+    if (hasStatic && !(staticMatch?.[1] ?? staticMatch?.[2] ?? '').trim()) {
+      errors.push(`${filePath}:${line} data-preview-static requires a reason.`);
+    }
+    if ((hasField || hasList || hasItem) && hasStatic) {
+      errors.push(
+        `${filePath}:${line} data-preview field/list/item markers cannot share an element with data-preview-static.`
+      );
+    }
+    if (hasField && BROAD_CONTENT_CONTAINERS.has(lowerTag)) {
+      errors.push(
+        `${filePath}:${line} data-preview-field-path cannot be placed on broad <${lowerTag}> content containers.`
+      );
+    }
+    if (hasStatic && BROAD_CONTENT_CONTAINERS.has(lowerTag)) {
+      errors.push(
+        `${filePath}:${line} data-preview-static cannot cover a broad <${lowerTag}> content container.`
+      );
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Detects the action/label collision the platform rejects: one element owning
+ * both an href/src action contract and different visible text.
+ */
+function auditActionLabelCollision(code, filePath) {
+  const errors = [];
+  const anchorPattern = /<a\b([^>]*?)>([\s\S]*?)<\/a>/gi;
+
+  for (const match of String(code).matchAll(anchorPattern)) {
+    const attrs = match[1] || '';
+    const inner = match[2] || '';
+    if (!/\bdata-preview-field-path\s*=/.test(attrs)) continue;
+    if (/\bdata-preview-field-path\s*=/.test(inner)) continue;
+
+    const visibleText = inner
+      .replace(/<[^>]*>/g, ' ')
+      .replace(/\{[^{}]*\}/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    if (visibleText.length > 2 && /\p{L}/u.test(visibleText)) {
+      errors.push(
+        `${filePath}:${lineNumberAt(code, match.index ?? 0)} data-preview-field-path covers both the <a> action and visible text "${visibleText.slice(0, 48)}". Move the label marker to a nested element.`
+      );
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Validates that every editable path implied by site-data/editorSchema is
+ * actually rendered somewhere in source (or declared control-only).
+ * This is the check that most commonly rejects auto-converted templates.
+ */
+function auditPathCoverage({ content, editorSchema, markers, controlOnlyPaths }) {
+  const errors = [];
+  const contentInventory = enumerateContentPaths(content);
+  const schemaInventory = enumerateSchemaPaths(editorSchema);
+
+  const fieldMarkers = new Set();
+  const listMarkers = new Set();
+  const itemMarkers = new Set();
+  const pageMarkers = new Set();
+
+  for (const marker of markers) {
+    const canonical = canonicalizeMarkerPath(marker.value);
+    if (marker.kind === 'page') {
+      pageMarkers.add(String(marker.value).trim());
+      continue;
+    }
+    if (!canonical) {
+      errors.push(
+        `${marker.filePath}:${marker.line} has invalid data-preview-${marker.kind}-path "${marker.value}".`
+      );
+      continue;
+    }
+    if (marker.kind === 'field') fieldMarkers.add(canonical);
+    if (marker.kind === 'list') listMarkers.add(canonical);
+    if (marker.kind === 'item') itemMarkers.add(canonical);
+  }
+
+  const covers = (markerSet, path) =>
+    markerSet.has(path) || [...markerSet].some((marker) => pathsOverlap(marker, path));
+
+  for (const path of contentInventory.concreteFields) {
+    if (isControlOnly(path, controlOnlyPaths)) continue;
+    if (covers(fieldMarkers, path)) continue;
+    errors.push(
+      `site-data content field "${path}" has no data-preview-field-path in source. Bind it, remove it, or declare it in visualEditing.controlOnlyPaths.`
+    );
+  }
+
+  for (const path of contentInventory.concreteLists) {
+    if (isControlOnly(path, controlOnlyPaths)) continue;
+    if (covers(listMarkers, path)) continue;
+    errors.push(
+      `site-data content list "${path}" has no data-preview-list-path in source.`
+    );
+  }
+
+  for (const path of contentInventory.concreteItems) {
+    if (isControlOnly(path, controlOnlyPaths)) continue;
+    if (covers(itemMarkers, path)) continue;
+    errors.push(
+      `site-data content list item "${path}" has no data-preview-item-path in source.`
+    );
+  }
+
+  const knownFieldPaths = [
+    ...contentInventory.fieldPatterns,
+    ...contentInventory.concreteFields,
+    ...schemaInventory.fieldPatterns,
+  ];
+  for (const marker of fieldMarkers) {
+    if (!knownFieldPaths.some((known) => pathsOverlap(marker, known))) {
+      errors.push(`data-preview-field-path references unknown path "${marker}".`);
+    }
+  }
+
+  const knownListPaths = [
+    ...contentInventory.listPatterns,
+    ...contentInventory.concreteLists,
+    ...schemaInventory.listPatterns,
+  ];
+  for (const marker of listMarkers) {
+    if (!knownListPaths.some((known) => pathsOverlap(marker, known))) {
+      errors.push(`data-preview-list-path references unknown path "${marker}".`);
+    }
+  }
+
+  return { errors, contentInventory, schemaInventory, fieldMarkers, listMarkers, itemMarkers, pageMarkers };
+}
+
+/** Ports validateSchemaPathUniqueness / section uniqueness. */
+function auditSchemaUniqueness(editorSchema) {
+  const errors = [];
+  const seenIds = new Set();
+  const seenSectionPaths = new Set();
+  const seenLeafPaths = new Map();
+
+  for (const section of editorSchema?.sections || []) {
+    if (seenIds.has(section.id)) {
+      errors.push(`editorSchema.sections contains duplicate id "${section.id}".`);
+    }
+    if (seenSectionPaths.has(section.path)) {
+      errors.push(`editorSchema.sections contains duplicate path "${section.path}".`);
+    }
+    seenIds.add(section.id);
+    seenSectionPaths.add(section.path);
+
+    walkLeaves(section.path, section, section.id);
+  }
+
+  function walkLeaves(path, node, sectionId) {
+    if (!node) return;
+    if (node.type === 'object') {
+      for (const field of node.fields || []) walkLeaves(appendPath(path, field.key), field, sectionId);
+      return;
+    }
+    if (node.type === 'list') {
+      const itemPath = `${wildcardPath(path)}[*]`;
+      registerLeaf(wildcardPath(path), sectionId, 'list');
+      for (const field of node.fields || []) walkLeaves(appendPath(itemPath, field.key), field, sectionId);
+      return;
+    }
+    if (!PRIMITIVE_TYPES.has(node.type)) {
+      errors.push(`editorSchema path "${path}" declares unsupported type "${node.type}".`);
+      return;
+    }
+    registerLeaf(wildcardPath(path), sectionId, 'field');
+  }
+
+  function registerLeaf(path, sectionId, kind) {
+    const previous = seenLeafPaths.get(path);
+    if (previous) {
+      errors.push(
+        `editorSchema declares duplicate editable ${kind} path "${path}" in sections "${previous.sectionId}" and "${sectionId}".`
+      );
+      return;
+    }
+    seenLeafPaths.set(path, { sectionId, kind });
+  }
+
+  return errors;
+}
+
+/** Ports validatePageCoverage against on-disk routes instead of exported HTML. */
+function auditPageCoverage({ pages, routeFiles, pageMarkersByFile }) {
+  const errors = [];
+  const seenIds = new Set();
+  const seenRoutes = new Map();
+
+  if (!pages || pages.length === 0) {
+    errors.push('Strict visual editing requires at least one manifest pages[] entry.');
+    return errors;
+  }
+
+  for (const page of pages) {
+    if (seenIds.has(page.id)) {
+      errors.push(`Manifest pages[] contains duplicate id "${page.id}".`);
+    }
+    seenIds.add(page.id);
+
+    const route = normalizePageRoute(page.route);
+    if (!route) {
+      errors.push(`Manifest page "${page.id}" must declare a canonical route.`);
+      continue;
+    }
+    const duplicate = seenRoutes.get(route);
+    if (duplicate) {
+      errors.push(`Manifest pages "${duplicate}" and "${page.id}" use duplicate route "${route}".`);
+    } else {
+      seenRoutes.set(route, page.id);
+    }
+
+    const sourceFile = routeFiles[page.id];
+    if (!sourceFile) {
+      errors.push(
+        `Manifest page "${page.id}" route "${route}" has no page file on disk, so the export cannot contain it.`
+      );
+      continue;
+    }
+    const keys = pageMarkersByFile[sourceFile] || [];
+    if (!keys.includes(page.id)) {
+      errors.push(`Route "${route}" (${sourceFile}) is missing data-preview-page-key="${page.id}".`);
+    }
+  }
+
+  return errors;
+}
+
+function normalizePageRoute(route) {
+  if (!route) return null;
+  const trimmed = String(route).trim();
+  if (!trimmed.startsWith('/') || trimmed.includes('?') || trimmed.includes('#') || trimmed.includes('..')) {
+    return null;
+  }
+  return trimmed === '/' ? trimmed : trimmed.replace(/\/+$/, '');
+}
+
+/** Ports validatePreviewRuntimeCapability's package-provider fast path. */
+function auditPreviewRuntime(sources) {
+  const joined = sources.join('\n');
+  const usesPackageProvider =
+    /(?:import|export)\s+[\s\S]*?\b(?:SiteDataProvider|BaseSiteDataProvider|useSiteData|DenebProvider|DenebSiteDataProvider|DenebUiProvider)\b[\s\S]*?\bfrom\s+['"][^'"]*['"]/m.test(joined) ||
+    /(?:import|export)\s+[\s\S]*?\bfrom\s+['"](?:@fivora\/|deneb-ui|@deneb-ui\/)/m.test(joined) ||
+    /<(?:SiteDataProvider|BaseSiteDataProvider|DenebProvider|DenebSiteDataProvider|DenebUiProvider)\b/m.test(joined);
+
+  return usesPackageProvider
+    ? []
+    : [
+        'Preview runtime is not certifiable: no @deneb-ui/ui SiteDataProvider/useSiteData usage was found. Mount SiteDataProvider in the root layout.',
+      ];
+}
+
+/**
+ * Finds meaningful visible JSX text that is neither bound to a field nor marked
+ * static. Strict mode treats these as errors in the exported HTML.
+ */
+function findUncoveredVisibleText(code, filePath) {
+  const findings = [];
+  const source = String(code);
+  const elementPattern = /<\s*([a-zA-Z][a-zA-Z0-9.:-]*)((?:[^<>{}]|\{[^{}]*\})*?)>([^<>{}]*)</g;
+
+  for (const match of source.matchAll(elementPattern)) {
+    const tag = match[1];
+    const attrs = match[2] || '';
+    const text = (match[3] || '').replace(/\s+/g, ' ').trim();
+    const offset = match.index ?? 0;
+
+    // A `<` preceded by an identifier character is a TypeScript generic
+    // (forwardRef<HTMLButtonElement, Props>), never a JSX element.
+    if (/[\w$)\]]/.test(source[offset - 1] || '')) continue;
+    if (!text || text.length <= 2 || !/\p{L}/u.test(text)) continue;
+    if (!/^[\p{L}\p{N}"'(¡¿#$€£]/u.test(text)) continue;
+    if (/^(?:true|false|null|undefined)$/i.test(text)) continue;
+    if (/\bdata-preview-(?:field-path|static)\b/.test(attrs)) continue;
+
+    findings.push({ tag, text, filePath, line: lineNumberAt(source, offset) });
+  }
+
+  return findings;
+}
+
+module.exports = {
+  BROAD_CONTENT_CONTAINERS,
+  PRIMITIVE_TYPES,
+  enumerateContentPaths,
+  enumerateSchemaPaths,
+  extractMarkers,
+  auditMarkerPlacement,
+  auditActionLabelCollision,
+  auditPathCoverage,
+  auditSchemaUniqueness,
+  auditPageCoverage,
+  auditPreviewRuntime,
+  findUncoveredVisibleText,
+  canonicalizeMarkerPath,
+  wildcardPath,
+  isControlOnly,
+  normalizePageRoute,
+};

package/src/arc/fs-utils.cjs

@@ -0,0 +1,170 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const IGNORE_DIRS = new Set([
+  '.git',
+  '.next',
+  '.turbo',
+  '.cache',
+  '.npm',
+  '.pnpm-store',
+  '.vercel',
+  '.output',
+  '.deneb',
+  'node_modules',
+  'out',
+  'dist',
+  'build',
+  'coverage',
+  '__macosx',
+]);
+
+function isIgnoredDirName(name) {
+  const lower = String(name || '').toLowerCase();
+  if (IGNORE_DIRS.has(lower)) return true;
+  if (lower.startsWith('.deneb-backup')) return true;
+  return false;
+}
+
+function isSecretFile(filename) {
+  const lower = String(filename || '').toLowerCase();
+  return (
+    lower.startsWith('.env') ||
+    lower.endsWith('.pem') ||
+    lower.endsWith('.key') ||
+    lower === 'id_rsa' ||
+    lower === 'credentials.json' ||
+    lower === '.npmrc'
+  );
+}
+
+function isSourceFile(filename) {
+  return /\.(tsx|jsx|ts|js|mjs|cjs)$/.test(filename) && !filename.endsWith('.d.ts');
+}
+
+function isJsxFile(filename) {
+  return /\.(tsx|jsx)$/.test(filename);
+}
+
+function readJsonSafe(filePath, fallback = null) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n', 'utf8');
+}
+
+function sha1(value) {
+  return crypto.createHash('sha1').update(String(value)).digest('hex');
+}
+
+function shortHash(value, length = 12) {
+  return sha1(value).slice(0, length);
+}
+
+function walkFiles(dir, options = {}, acc = []) {
+  if (!dir || !fs.existsSync(dir)) return acc;
+  const include = options.include || (() => true);
+  const follow = options.followDirectories !== false;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!follow || isIgnoredDirName(entry.name)) continue;
+      walkFiles(fullPath, options, acc);
+    } else if (entry.isFile()) {
+      if (isSecretFile(entry.name)) continue;
+      if (include(fullPath, entry.name)) acc.push(fullPath);
+    }
+  }
+  return acc;
+}
+
+function detectPackageManager(projectDir) {
+  if (fs.existsSync(path.join(projectDir, 'bun.lock')) || fs.existsSync(path.join(projectDir, 'bun.lockb'))) {
+    return 'bun';
+  }
+  if (fs.existsSync(path.join(projectDir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(projectDir, 'yarn.lock'))) return 'yarn';
+  if (fs.existsSync(path.join(projectDir, 'package-lock.json'))) return 'npm';
+  return 'npm';
+}
+
+function findFirstExisting(paths) {
+  for (const candidate of paths) {
+    if (candidate && fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function rel(projectDir, filePath) {
+  return path.relative(projectDir, filePath).replace(/\\/g, '/');
+}
+
+function homeDenebDir() {
+  return path.join(os.homedir(), '.deneb');
+}
+
+function copyFilePreserve(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function deepMerge(target, source) {
+  if (!isPlainObject(source)) return target;
+  const output = isPlainObject(target) ? { ...target } : {};
+  for (const [key, value] of Object.entries(source)) {
+    if (isPlainObject(value) && isPlainObject(output[key])) {
+      output[key] = deepMerge(output[key], value);
+    } else if (output[key] === undefined) {
+      output[key] = value;
+    }
+  }
+  return output;
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function toPosix(filePath) {
+  return String(filePath || '').replace(/\\/g, '/');
+}
+
+module.exports = {
+  IGNORE_DIRS,
+  isIgnoredDirName,
+  isSecretFile,
+  isSourceFile,
+  isJsxFile,
+  readJsonSafe,
+  writeJson,
+  sha1,
+  shortHash,
+  walkFiles,
+  detectPackageManager,
+  findFirstExisting,
+  rel,
+  homeDenebDir,
+  copyFilePreserve,
+  deepMerge,
+  isPlainObject,
+  toPosix,
+};