@adobe/aem-cli 16.17.1 → 16.18.0

package/src/content/content-git.js

@@ -0,0 +1,181 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import path from 'path';
+import fse from 'fs-extra';
+import git from 'isomorphic-git';
+
+/** Ref pointing at the last commit whose tree was fully synced to da.live. */
+export const DA_SYNCED_REF = 'refs/da/synced';
+
+/**
+ * OID of the last da.live sync. Uses refs/da/synced when present; otherwise infers
+ * from commit history (newest `push:` then `clone:`) so repos created before the ref
+ * existed still compare against the correct baseline.
+ * @param {import('isomorphic-git').FsClient} fs
+ * @param {string} dir
+ * @returns {Promise<string>}
+ */
+export async function resolveSyncedOid(fs, dir) {
+  try {
+    return await git.resolveRef({ fs, dir, ref: DA_SYNCED_REF });
+  } catch (err) {
+    if (err && (err.code === 'NotFoundError' || err.name === 'NotFoundError')) {
+      const commits = await git.log({ fs, dir, depth: 500 });
+      for (const c of commits) {
+        if (String(c.commit.message).startsWith('push:')) {
+          return c.oid;
+        }
+      }
+      for (const c of commits) {
+        if (String(c.commit.message).startsWith('clone:')) {
+          return c.oid;
+        }
+      }
+      return git.resolveRef({ fs, dir, ref: 'HEAD' });
+    }
+    throw err;
+  }
+}
+
+/**
+ * @param {import('isomorphic-git').FsClient} fs
+ * @param {string} dir
+ * @param {string} oid
+ * @returns {Promise<void>}
+ */
+export async function writeSyncedRef(fs, dir, oid) {
+  await git.writeRef({
+    fs,
+    dir,
+    ref: DA_SYNCED_REF,
+    value: oid,
+    force: true,
+  });
+}
+
+/**
+ * True when the index or working tree differs from HEAD (uncommitted work).
+ * @param {Array<[string, number, number, number]>} matrix
+ * @returns {boolean}
+ */
+export function statusMatrixHasUncommitted(matrix) {
+  return matrix.some(([, h, w, s]) => !(h === 1 && w === 1 && s === 1));
+}
+
+/**
+ * Diff trees at two commits: paths as da.live paths (`/file`).
+ * @param {import('isomorphic-git').FsClient} fs
+ * @param {string} dir
+ * @param {string} baseOid
+ * @param {string} headOid
+ * @returns {Promise<{ added: string[], modified: string[], deleted: string[] }>}
+ */
+export async function diffCommitTrees(fs, dir, baseOid, headOid) {
+  if (baseOid === headOid) {
+    return { added: [], modified: [], deleted: [] };
+  }
+
+  const baseFiles = new Set(await git.listFiles({ fs, dir, ref: baseOid }));
+  const headFiles = new Set(await git.listFiles({ fs, dir, ref: headOid }));
+
+  const added = [];
+  const modified = [];
+  const deleted = [];
+
+  for (const f of headFiles) {
+    if (!baseFiles.has(f)) {
+      added.push(`/${f}`);
+    } else {
+      // eslint-disable-next-line no-await-in-loop
+      const b1 = await git.readBlob({
+        fs,
+        dir,
+        oid: baseOid,
+        filepath: f,
+      });
+      // eslint-disable-next-line no-await-in-loop
+      const b2 = await git.readBlob({
+        fs,
+        dir,
+        oid: headOid,
+        filepath: f,
+      });
+      if (b1.oid !== b2.oid) {
+        modified.push(`/${f}`);
+      }
+    }
+  }
+
+  for (const f of baseFiles) {
+    if (!headFiles.has(f)) {
+      deleted.push(`/${f}`);
+    }
+  }
+
+  return { added, modified, deleted };
+}
+
+/**
+ * Number of commits reachable from `tipOid` before hitting `ancestorOid` (exclusive).
+ * @param {import('isomorphic-git').FsClient} fs
+ * @param {string} dir
+ * @param {string} tipOid
+ * @param {string} ancestorOid
+ * @returns {Promise<number>}
+ */
+export async function countCommitsAhead(fs, dir, tipOid, ancestorOid) {
+  if (tipOid === ancestorOid) {
+    return 0;
+  }
+  const commits = await git.log({
+    fs,
+    dir,
+    ref: tipOid,
+    depth: 5000,
+  });
+  let n = 0;
+  for (const c of commits) {
+    if (c.oid === ancestorOid) {
+      return n;
+    }
+    n += 1;
+  }
+  return n;
+}
+
+/**
+ * Committer time in ms for conflict checks (da.live lastModified).
+ * @param {import('isomorphic-git').FsClient} fs
+ * @param {string} dir
+ * @param {string} commitOid
+ * @returns {Promise<number>}
+ */
+export async function getCommitCommitterTimeMs(fs, dir, commitOid) {
+  const { commit } = await git.readCommit({ fs, dir, oid: commitOid });
+  return commit.committer.timestamp * 1000;
+}
+
+/**
+ * Ensures an entry is present in the project .gitignore, creating the file if needed.
+ * @param {string} projectDir
+ * @param {string} entry
+ */
+export async function ensureGitIgnored(projectDir, entry) {
+  const gitIgnorePath = path.resolve(projectDir, '.gitignore');
+  let content = '';
+  if (await fse.pathExists(gitIgnorePath)) {
+    content = await fse.readFile(gitIgnorePath, 'utf-8');
+  }
+  if (!content.split('\n').map((l) => l.trim()).includes(entry)) {
+    await fse.appendFile(gitIgnorePath, `\n${entry}\n`);
+  }
+}

package/src/content/content-metadata-html.js

@@ -0,0 +1,321 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/**
+ * Transforms da.live-style `<div class="metadata">` blocks in content HTML into
+ * `<meta>` tags for local dev (`aem up`), strips the block from the body, and
+ * adds description / Open Graph / Twitter tags where data is available.
+ */
+
+import { unified } from 'unified';
+import rehypeParse from 'rehype-parse';
+import { select } from 'hast-util-select';
+import { toHtml } from 'hast-util-to-html';
+
+/** @typedef {import('hast').Root} HastRoot */
+/** @typedef {import('hast').Element} HastElement */
+
+const REHYPE_PARSE = { fragment: true };
+
+/**
+ * @param {string} s
+ * @returns {string}
+ */
+export function escapeHtmlAttr(s) {
+  return String(s)
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;');
+}
+
+/**
+ * @param {string} label
+ * @returns {string}
+ */
+export function slugifyMetadataLabel(label) {
+  return label
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+/**
+ * @param {import('hast').Node | null | undefined} node
+ * @returns {string}
+ */
+function textContent(node) {
+  if (!node) {
+    return '';
+  }
+  if (node.type === 'text') {
+    return node.value;
+  }
+  if (Array.isArray(node.children)) {
+    return node.children.map((c) => textContent(c)).join('');
+  }
+  return '';
+}
+
+/**
+ * @param {HastElement} metadataRoot
+ * @returns {Array<[string, string]>}
+ */
+export function extractMetadataPairs(metadataRoot) {
+  /** @type {Array<[string, string]>} */
+  const pairs = [];
+  if (!metadataRoot.children) {
+    return pairs;
+  }
+  for (const row of metadataRoot.children) {
+    if (row.type !== 'element' || row.tagName !== 'div') {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    const cells = (row.children || []).filter(
+      (c) => c.type === 'element' && c.tagName === 'div',
+    );
+    if (cells.length < 2) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    const label = textContent(cells[0]).trim();
+    const value = textContent(cells[1]).trim();
+    if (label) {
+      pairs.push([label, value]);
+    }
+  }
+  return pairs;
+}
+
+/**
+ * @param {HastElement} node
+ * @param {string} className
+ * @returns {boolean}
+ */
+function hasClass(node, className) {
+  const cn = node.properties?.className;
+  if (Array.isArray(cn)) {
+    return cn.includes(className);
+  }
+  if (typeof cn === 'string') {
+    return cn.split(/\s+/).includes(className);
+  }
+  return false;
+}
+
+/**
+ * @param {import('hast').Node} tree
+ * @param {import('hast').Element} target
+ * @returns {boolean}
+ */
+function removeNode(tree, target) {
+  if (tree === target) {
+    return true;
+  }
+  if ('children' in tree && Array.isArray(tree.children)) {
+    const { children } = tree;
+    for (let i = 0; i < children.length; i += 1) {
+      const c = children[i];
+      if (c === target) {
+        children.splice(i, 1);
+        return true;
+      }
+      if (removeNode(c, target)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {HastRoot} tree
+ * @returns {string}
+ */
+function firstImgSrc(tree) {
+  const img = select('img[src]', tree);
+  if (!img || img.type !== 'element') {
+    return '';
+  }
+  const s = img.properties?.src;
+  return typeof s === 'string' ? s : '';
+}
+
+/**
+ * @param {HastRoot} tree
+ * @returns {string}
+ */
+function firstParagraphText(tree) {
+  const p = select('p', tree);
+  return p && p.type === 'element' ? textContent(p).trim() : '';
+}
+
+/**
+ * Truncates a string to `max` characters, trimming and appending an ellipsis when needed.
+ * @param {string} s
+ * @param {number} max
+ * @returns {string}
+ */
+function truncateWithEllipsis(s, max) {
+  if (s.length <= max) {
+    return s;
+  }
+  return `${s.slice(0, max - 1).trim()}…`;
+}
+
+const SEO_LABEL_SKIP = new Set(['title', 'description', 'image']);
+
+/**
+ * @param {object | null | undefined} sheetRow row from /metadata.json matched for this URL
+ * @param {Set<string> | null | undefined} excludeMetaNames lowercase meta `name` values to skip
+ *   (local page wins)
+ * @returns {string[]}
+ */
+export function buildSheetMetaLines(sheetRow, excludeMetaNames) {
+  if (!sheetRow || typeof sheetRow !== 'object') {
+    return [];
+  }
+  /** @type {string[]} */
+  const lines = [];
+  for (const [k, v] of Object.entries(sheetRow)) {
+    if (k === 'URL' || k.startsWith(':')) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    if (excludeMetaNames && excludeMetaNames.has(k.toLowerCase())) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    if (v === undefined || v === null) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    const s = String(v).trim();
+    if (!s) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    lines.push(`<meta name="${escapeHtmlAttr(k)}" content="${escapeHtmlAttr(s)}">`);
+  }
+  return lines;
+}
+
+/**
+ * @param {string[]} lines
+ * @returns {string}
+ */
+function joinLines(lines) {
+  return lines.length > 0 ? `\n${lines.join('\n')}\n` : '';
+}
+
+/**
+ * @param {string} htmlFragment body-only or partial HTML from content/
+ * @param {{ absolutePageUrl?: string, sheetRow?: object | null }} [options]
+ * @returns {{ htmlFragment: string, metaTagsHtml: string }}
+ */
+export function transformContentMetadataHtml(htmlFragment, options = {}) {
+  const { absolutePageUrl = '', sheetRow = null } = options;
+
+  let tree;
+  try {
+    tree = unified().use(rehypeParse, REHYPE_PARSE).parse(htmlFragment);
+  } catch {
+    return { htmlFragment, metaTagsHtml: joinLines(buildSheetMetaLines(sheetRow)) };
+  }
+
+  const metadataEl = select('div.metadata', tree);
+  if (!metadataEl || metadataEl.type !== 'element' || !hasClass(metadataEl, 'metadata')) {
+    return { htmlFragment, metaTagsHtml: joinLines(buildSheetMetaLines(sheetRow)) };
+  }
+
+  const pairs = extractMetadataPairs(metadataEl);
+
+  /** Names from page metadata; sheet entries with the same meta name are skipped. */
+  const localPairMetaNames = new Set();
+  for (const [label, value] of pairs) {
+    const slug = slugifyMetadataLabel(label);
+    if (!slug || value === undefined) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    localPairMetaNames.add(slug);
+  }
+
+  const sheetLines = buildSheetMetaLines(sheetRow, localPairMetaNames);
+
+  const lowerMap = new Map(pairs.map(([k, v]) => [k.toLowerCase().trim(), v]));
+
+  removeNode(tree, metadataEl);
+
+  const title = (lowerMap.get('title') || textContent(select('h1', tree)).trim() || '').trim();
+  let description = (lowerMap.get('description') || firstParagraphText(tree) || '').trim();
+  description = truncateWithEllipsis(description, 200);
+  const image = (lowerMap.get('image') || lowerMap.get('og image') || firstImgSrc(tree) || '').trim();
+
+  /** @type {string[]} */
+  const seoLines = [];
+
+  if (description) {
+    const e = escapeHtmlAttr(description);
+    seoLines.push(`<meta name="description" content="${e}">`);
+    seoLines.push(`<meta property="og:description" content="${e}">`);
+    seoLines.push(`<meta name="twitter:description" content="${e}">`);
+  }
+
+  if (title) {
+    const e = escapeHtmlAttr(title);
+    seoLines.push(`<meta property="og:title" content="${e}">`);
+    seoLines.push(`<meta name="twitter:title" content="${e}">`);
+  }
+
+  if (absolutePageUrl) {
+    seoLines.push(`<meta property="og:url" content="${escapeHtmlAttr(absolutePageUrl)}">`);
+  }
+
+  if (image) {
+    const e = escapeHtmlAttr(image);
+    const alt = escapeHtmlAttr(title || 'image');
+    seoLines.push(`<meta property="og:image" content="${e}">`);
+    seoLines.push(`<meta property="og:image:secure_url" content="${e}">`);
+    seoLines.push(`<meta property="og:image:alt" content="${alt}">`);
+    seoLines.push('<meta name="twitter:card" content="summary_large_image">');
+    seoLines.push(`<meta name="twitter:image" content="${e}">`);
+  } else {
+    seoLines.push('<meta name="twitter:card" content="summary">');
+  }
+
+  /** @type {string[]} */
+  const pairLines = [];
+  for (const [label, value] of pairs) {
+    const key = label.toLowerCase().trim();
+    if (SEO_LABEL_SKIP.has(key)) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    const slug = slugifyMetadataLabel(label);
+    if (!slug || value === undefined) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    pairLines.push(
+      `<meta name="${escapeHtmlAttr(slug)}" content="${escapeHtmlAttr(value)}">`,
+    );
+  }
+
+  // SEO first, then sheet (fields not overridden by local pairs), then local page metadata
+  const allLines = [...seoLines, ...sheetLines, ...pairLines];
+  const htmlOut = toHtml(tree);
+  return { htmlFragment: htmlOut, metaTagsHtml: joinLines(allLines) };
+}

package/src/content/content-shared.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export const CONTENT_DIR = 'content';
+export const CONFIG_FILE = '.da-config.json';
+export const GIT_AUTHOR = { name: 'aem-cli', email: 'aem-cli@adobe.com' };
+
+/** Above this count, clone warns and requires confirmation (or --yes). */
+export const LARGE_CLONE_FILE_THRESHOLD = 10000;
+
+/**
+ * Parallelism for da.live I/O: recursive list fan-out, clone downloads, push uploads/deletes.
+ */
+export const CONTENT_IO_CONCURRENCY = 10;
+
+/**
+ * Normalizes a da.live path: leading slash, no trailing slash except root.
+ * @param {string} input
+ * @returns {string}
+ * @throws {Error} if input is null, undefined, or empty
+ */
+export function normalizeDaPath(input) {
+  if (input === undefined || input === null) {
+    throw new Error('Content path is required.');
+  }
+  let s = String(input).trim();
+  if (s === '') {
+    throw new Error('Content path cannot be empty.');
+  }
+  if (!s.startsWith('/')) {
+    s = `/${s}`;
+  }
+  s = s.replace(/\/+$/, '') || '/';
+  return s;
+}

package/src/content/content.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import clone from './clone.js';
+import add from './add.js';
+import commit from './commit.js';
+import push from './push.js';
+import status from './status.js';
+import diff from './diff.js';
+import mergeCmd from './merge.js';
+
+export default function content() {
+  return {
+    command: 'content',
+    description: 'Manage AEM content from da.live',
+    builder: (yargs) => {
+      yargs
+        .command(clone())
+        .command(add())
+        .command(commit())
+        .command(push())
+        .command(status())
+        .command(diff())
+        .command(mergeCmd())
+        .demandCommand(1, 'You need at least one content subcommand.')
+        .help();
+    },
+    handler: () => {},
+  };
+}