aem-eds-cli 1.0.0

package/LICENSE

@@ -0,0 +1,52 @@
+Apache License
+Version 2.0, January 2004
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined in Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original Work and any Derivative Works thereof, that is intentionally submitted to, or received by, Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work.
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contribution.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License.
+
+END OF TERMS AND CONDITIONS

package/bin/aem-eds.js

@@ -0,0 +1,967 @@
+#!/usr/bin/env node
+
+/**
+ * AEM EDS Block Scaffolder
+ *
+ * Commands:
+ *   eds-scaffold create [block-name]   Scaffold a new block
+ *   eds-scaffold remove <block-name>   Delete block folder (JSON goes with it)
+ *   eds-scaffold list                  Show all blocks with status
+ *
+ * Flags:
+ *   --dry-run    Print what would be generated without writing any files
+ *
+ * Block-level JSON pattern:
+ *   Each block owns blocks/<name>/_<name>.json containing its definitions,
+ *   models and filters. Run `npm run build:json` (merge-json-cli in the
+ *   boilerplate) to assemble the global component-*.json files.
+ *   Never edit global files by hand.
+ */
+
+const fs        = require('fs');
+const path      = require('path');
+const readline  = require('readline');
+
+// ─── ANSI colours ─────────────────────────────────────────────────────────────
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[32m', cyan: '\x1b[36m', yellow: '\x1b[33m', red: '\x1b[31m',
+};
+
+const log = {
+  info:    (m) => console.log(`  ${c.cyan}ℹ${c.reset}  ${m}`),
+  success: (m) => console.log(`  ${c.green}✔${c.reset}  ${m}`),
+  warn:    (m) => console.log(`  ${c.yellow}⚠${c.reset}  ${m}`),
+  error:   (m) => console.log(`  ${c.red}✖${c.reset}  ${m}`),
+  dry:     (m) => console.log(`  ${c.yellow}~${c.reset}  ${c.dim}[dry-run]${c.reset} ${m}`),
+  title:   (m) => console.log(`\n${c.bold}${c.cyan}${m}${c.reset}\n`),
+  divider: ()  => console.log(`  ${c.dim}${'─'.repeat(50)}${c.reset}`),
+  blank:   ()  => console.log(''),
+  section: (m) => console.log(`\n  ${c.bold}${m}${c.reset}\n`),
+};
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const toTitleCase   = (s) => s.replace(/-/g, ' ').replace(/\b\w/g, (ch) => ch.toUpperCase());
+const isValidName   = (s) => /^[a-z][a-z0-9-]*$/.test(s);
+const prompt        = (rl, q) => new Promise((res) => rl.question(`  ${q}`, res));
+const confirm       = async (rl, q, def = true) => {
+  const hint = def ? '[Y/n]' : '[y/N]';
+  const a = (await prompt(rl, `${q} ${c.dim}${hint}${c.reset} `)).trim().toLowerCase();
+  return !a ? def : a === 'y' || a === 'yes';
+};
+const readJSON  = (p) => { try { return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null; } catch { return null; } };
+const tick      = (v) => v ? `${c.green}✔${c.reset}` : `${c.red}✖${c.reset}`;
+const col       = (s, w) => String(s || '').padEnd(w).slice(0, w);
+
+// ─── Field types ──────────────────────────────────────────────────────────────
+const FIELD_TYPES = {
+  text:                      { label: 'Single-line text',                valueType: 'string',   multi: true  },
+  textarea:                  { label: 'Multi-line plain text',           valueType: 'string',   multi: false },
+  richtext:                  { label: 'Rich text (HTML / WYSIWYG)',      valueType: 'string',   multi: false },
+  reference:                 { label: 'Image / Media (DAM asset)',       valueType: 'string',   multi: true  },
+  'aem-content':             { label: 'AEM page / content / link',       valueType: 'string',   multi: true  },
+  'aem-content-fragment':    { label: 'Content Fragment picker',         valueType: 'string',   multi: false },
+  'aem-experience-fragment': { label: 'Experience Fragment picker',      valueType: 'string',   multi: false },
+  boolean:                   { label: 'Boolean toggle (true / false)',   valueType: 'boolean',  multi: false },
+  select:                    { label: 'Dropdown — single value',         valueType: 'string',   multi: false },
+  multiselect:               { label: 'Dropdown — multiple values',      valueType: 'string[]', multi: false },
+  'radio-group':             { label: 'Radio buttons — single value',    valueType: 'string',   multi: false },
+  'checkbox-group':          { label: 'Checkboxes — multiple values',    valueType: 'string[]', multi: false },
+  number:                    { label: 'Number input',                    valueType: 'number',   multi: false },
+  'date-time':               { label: 'Date / time picker',             valueType: 'date',     multi: false },
+  'aem-tag':                 { label: 'AEM Tag picker (cq:tags)',        valueType: 'string',   multi: false },
+  container:                 { label: 'Grouped / repeating field set',   valueType: 'string',   multi: false },
+  tab:                       { label: 'Tab — organises fields in panel', valueType: null,       multi: false },
+};
+
+const FIELD_GROUPS = [
+  { title: 'Text inputs',         keys: ['text', 'textarea', 'richtext'] },
+  { title: 'Media & references',  keys: ['reference', 'aem-content', 'aem-content-fragment', 'aem-experience-fragment'] },
+  { title: 'Selection & toggles', keys: ['boolean', 'select', 'multiselect', 'radio-group', 'checkbox-group'] },
+  { title: 'Specialised',         keys: ['number', 'date-time', 'aem-tag'] },
+  { title: 'Layout (no value)',   keys: ['container', 'tab'] },
+];
+
+const ALL_FIELD_KEYS = Object.keys(FIELD_TYPES);
+
+function printFieldTypes() {
+  let idx = 1;
+  for (const group of FIELD_GROUPS) {
+    console.log(`\n  ${c.dim}── ${group.title} ${'─'.repeat(28 - group.title.length)}${c.reset}`);
+    for (const k of group.keys) {
+      const e  = FIELD_TYPES[k];
+      const vt = e.valueType ? `${c.dim}[${e.valueType}]${c.reset}` : `${c.dim}[layout]${c.reset}`;
+      const mu = e.multi ? ` ${c.dim}(multi ok)${c.reset}` : '';
+      console.log(`  ${c.dim}${String(idx).padStart(3)}.${c.reset} ${c.cyan}${k.padEnd(26)}${c.reset}${vt}${mu} ${c.dim}${e.label}${c.reset}`);
+      idx++;
+    }
+  }
+  console.log('');
+}
+
+// ─── Validation config ────────────────────────────────────────────────────────
+const VALIDATIONS = {
+  text:                     ['required', 'description', 'readOnly', 'hidden', 'minLength', 'maxLength'],
+  textarea:                 ['required', 'description', 'readOnly', 'hidden', 'minLength', 'maxLength'],
+  richtext:                 ['required', 'description', 'readOnly', 'hidden'],
+  reference:                ['required', 'description', 'readOnly', 'hidden'],
+  'aem-content':            ['required', 'description', 'readOnly', 'hidden', 'rootPath'],
+  'aem-content-fragment':   ['required', 'description', 'readOnly', 'hidden', 'rootPath'],
+  'aem-experience-fragment':['required', 'description', 'readOnly', 'hidden'],
+  boolean:                  ['description', 'readOnly', 'hidden', 'customErrorMsg'],
+  select:                   ['required', 'description', 'readOnly', 'hidden'],
+  multiselect:              ['required', 'description', 'readOnly', 'hidden'],
+  'radio-group':            ['required', 'description', 'readOnly', 'hidden'],
+  'checkbox-group':         ['required', 'description', 'readOnly', 'hidden'],
+  number:                   ['required', 'description', 'readOnly', 'hidden', 'min', 'max', 'step'],
+  'date-time':              ['required', 'description', 'readOnly', 'hidden', 'min', 'max'],
+  'aem-tag':                ['required', 'description', 'readOnly', 'hidden'],
+  container:                ['description', 'readOnly', 'hidden'],
+  tab:                      [],
+};
+
+// ─── Field schema builder ─────────────────────────────────────────────────────
+const OPTION_TYPES = new Set(['select', 'multiselect', 'radio-group', 'checkbox-group']);
+
+function buildFieldSchema(fields) {
+  return fields.map((f) => {
+    const base = { component: f.type, name: f.name, label: f.label };
+    if (f.type !== 'tab')    base.valueType   = FIELD_TYPES[f.type]?.valueType || 'string';
+    if (f.required)          base.required    = true;
+    if (f.readOnly)          base.readOnly    = true;
+    if (f.hidden)            base.hidden      = true;
+    if (f.description)       base.description = f.description;
+    if (f.multi)             base.multi       = true;
+    else if (f.type === 'reference') base.multi = false;
+
+    // Real options from collector (or placeholder fallback)
+    if (OPTION_TYPES.has(f.type)) {
+      base.options = f.options?.length
+        ? f.options
+        : [{ name: 'Option 1', value: 'option-1' }, { name: 'Option 2', value: 'option-2' }];
+    }
+
+    // Default value
+    if (f.defaultValue !== undefined && f.defaultValue !== '') {
+      base.value = f.type === 'number'  ? Number(f.defaultValue)
+                 : f.type === 'boolean' ? (f.defaultValue === 'true' || f.defaultValue === true)
+                 : f.defaultValue;
+    }
+
+    if (f.type === 'date-time') { base.displayFormat = 'YYYY-MM-DD'; base.valueFormat = 'YYYY-MM-DD'; }
+    if (f.type === 'aem-content-fragment') base.variationName = '';
+
+    const validation = {};
+    if (f.minLength !== undefined)  validation.minLength      = f.minLength;
+    if (f.maxLength !== undefined)  validation.maxLength      = f.maxLength;
+    if (f.rootPath)                 validation.rootPath       = f.rootPath;
+    if (f.customErrorMsg)           validation.customErrorMsg = f.customErrorMsg;
+    if (Object.keys(validation).length) base.validation = validation;
+
+    // number / date-time constraints go TOP-LEVEL — not inside validation.
+    // UE maps these directly to HTML input attributes (min, max, step).
+    // Nesting them under validation means UE ignores them entirely.
+    if (f.min  !== undefined) base.min  = f.min;
+    if (f.max  !== undefined) base.max  = f.max;
+    if (f.step !== undefined) base.step = f.step;
+
+    if (f.type === 'container') {
+      base.collapsible = true;
+      base.fields = f.subFields?.length ? buildFieldSchema(f.subFields) : [];
+    }
+    return base;
+  });
+}
+
+// ─── JS template — simple block ───────────────────────────────────────────────
+function genSimpleBlockJS(blockName) {
+  return `export default function decorate(block) {
+  // TODO: implement ${blockName} block
+}
+`;
+}
+
+// ─── JS template — multi-row block ───────────────────────────────────────────
+function genMultiRowBlockJS(blockName) {
+  return `export default function decorate(block) {
+  const rows = [...block.children];
+  rows.forEach((row) => {
+    // TODO: implement ${blockName} row decoration
+  });
+}
+`;
+}
+
+// ─── JS template — container block ───────────────────────────────────────────
+function genContainerBlockJS(blockName, childName) {
+  return `export default function decorate(block) {
+  const [, ...itemRows] = [...block.children];
+  itemRows.forEach((item) => {
+    item.classList.add('${blockName}__item');
+    // TODO: implement ${childName} item decoration
+  });
+}
+`;
+}
+
+// ─── CSS template ─────────────────────────────────────────────────────────────
+function genBlockCSS(blockName) {
+  return `.${blockName} {
+  display: block;
+}
+`;
+}
+
+// ─── README template ──────────────────────────────────────────────────────────
+function genReadme(blockName, isContainer, parentFields, childName, childFields, needsVariants = false) {
+  const title      = toTitleCase(blockName);
+  const childTitle = toTitleCase(childName);
+
+  // ── Field reference table ─────────────────────────────────────────────────
+  const buildTable = (fields, heading) => {
+    if (!fields.length) return `### ${heading}\n\n*No fields defined.*`;
+    const rows = fields.map((f) => {
+      const req    = f.required     ? ' *(required)*'          : '';
+      const multi  = f.multi        ? ' *(multi)*'             : '';
+      const opts   = f.options?.length
+        ? f.options.map((o) => `\`${o.value}\``).join(', ')   : '—';
+      const defVal = f.defaultValue !== undefined
+        ? `\`${f.defaultValue}\``                              : '—';
+      const valid  = [
+        f.minLength !== undefined && `minLength: ${f.minLength}`,
+        f.maxLength !== undefined && `maxLength: ${f.maxLength}`,
+        f.min       !== undefined && `min: ${f.min}`,
+        f.max       !== undefined && `max: ${f.max}`,
+        f.rootPath                && `rootPath: ${f.rootPath}`,
+      ].filter(Boolean).join(', ') || '—';
+      return `| ${f.label}${req} | \`${f.type}\`${multi} | \`${f.name}\` | ${opts} | ${defVal} | ${valid} |`;
+    }).join('\n');
+    return `### ${heading}\n\n| Label | Type | Property | Options | Default | Validation |\n|---|---|---|---|---|---|\n${rows}`;
+  };
+
+  // ── UE authoring steps ────────────────────────────────────────────────────
+  const simpleSteps = () => `
+1. Open your page in **Universal Editor**
+2. Click **+** inside a Section to open the block picker
+3. Select **${title}** from the list
+4. The block is added — click on it to open the **Properties panel**
+5. Fill in the fields:
+
+${parentFields.map((f, i) => {
+    const hint = f.type === 'reference'
+      ? '→ opens DAM asset picker'
+      : f.type === 'aem-content'
+      ? '→ opens page / link picker'
+      : f.type === 'select' || f.type === 'radio-group'
+      ? `→ choose one of: ${(f.options||[]).map(o=>o.value).join(', ')}`
+      : f.type === 'boolean'
+      ? '→ toggle on / off'
+      : f.type === 'richtext'
+      ? '→ rich text editor opens inline'
+      : f.type === 'number'
+      ? `→ numeric input${f.min !== undefined ? ` (${f.min}–${f.max})` : ''}`
+      : '';
+    return `   ${i + 1}. **${f.label}**${f.required ? ' *(required)*' : ''} ${hint}`;
+  }).join('\n')}
+
+6. Click **✓ Save** in the Properties panel
+7. Click **Publish** in the UE toolbar when ready`;
+
+  const containerSteps = () => `
+**Step 1 — Add the ${title} block**
+
+1. Open your page in **Universal Editor**
+2. Click **+** inside a Section to open the block picker
+3. Select **${title}** from the list
+4. The block is added — click on it to open the **Properties panel**
+${parentFields.length ? `5. Fill in the block config fields:
+
+${parentFields.map((f, i) => {
+    const hint = f.type === 'number'
+      ? `→ numeric input${f.min !== undefined ? ` (${f.min}–${f.max})` : ''}`
+      : f.type === 'boolean' ? '→ toggle on / off'
+      : f.type === 'select'  ? `→ choose: ${(f.options||[]).map(o=>o.value).join(', ')}`
+      : '';
+    return `   ${i + 1}. **${f.label}**${f.required ? ' *(required)*' : ''} ${hint}`;
+  }).join('\n')}
+6. Click **✓ Save**` : `5. This block has no config fields — proceed to adding child items`}
+
+---
+
+**Step 2 — Add ${childTitle} items**
+
+1. Click **+** inside the **${title}** block *(not the section + button)*
+2. Select **${childTitle}** from the picker
+3. Click on the new item to open its **Properties panel**
+4. Fill in the item fields:
+
+${childFields.map((f, i) => {
+    const hint = f.type === 'reference'
+      ? '→ opens DAM asset picker'
+      : f.type === 'aem-content'
+      ? '→ opens page / link picker'
+      : f.type === 'richtext'
+      ? '→ rich text editor opens inline'
+      : f.type === 'boolean'
+      ? '→ toggle on / off'
+      : f.type === 'select' || f.type === 'radio-group'
+      ? `→ choose one of: ${(f.options||[]).map(o=>o.value).join(', ')}`
+      : '';
+    return `   ${i + 1}. **${f.label}**${f.required ? ' *(required)*' : ''} ${hint}`;
+  }).join('\n')}
+
+5. Click **✓ Save**
+6. Repeat from step 1 to add more ${childTitle} items
+7. Click **Publish** in the UE toolbar when ready`;
+
+  // ── Variants section ──────────────────────────────────────────────────────
+  const variantsSection = needsVariants ? `## Variants
+
+Select the **${title}** block in UE → open the **Properties panel** → type variant
+names in the **Variants (comma-separated)** field.
+
+Each value maps directly to a CSS class on the block element:
+
+| Variant value | CSS class applied | Example use |
+|---|---|---|
+| \`dark\` | \`.${blockName}.dark\` | Dark background |
+| \`light\` | \`.${blockName}.light\` | Light background |
+| \`compact\` | \`.${blockName}.compact\` | Reduced padding |
+
+Multiple variants are supported: \`dark, compact\` → \`.${blockName}.dark.compact\`
+
+> Add your own variants in \`${blockName}.css\`.
+
+---` : `## Variants
+
+This block was scaffolded without variant support.
+To add variants later, add a \`classes\` text field to the model in \`_${blockName}.json\`
+and rebuild with \`npm run build:json\`.
+
+---`;
+
+  // ── Full README ───────────────────────────────────────────────────────────
+  return `# ${title} Block
+
+${isContainer
+    ? `Container block — a **${title}** holds one or more **${childTitle}** child items, each authored separately in Universal Editor.`
+    : `Simple block — all fields are authored together in the Universal Editor Properties panel.`}
+
+---
+
+## Authoring in Universal Editor
+${isContainer ? containerSteps() : simpleSteps()}
+
+---
+
+## Field reference
+
+${isContainer
+    ? [
+        parentFields.length
+          ? buildTable(parentFields, `${title} — config fields`)
+          : `### ${title} — config fields\n\n*No config fields on this block.*`,
+        buildTable(childFields, `${childTitle} — item fields`),
+      ].join('\n\n')
+    : buildTable(parentFields, `${title} — fields`)}
+
+---
+
+${variantsSection}
+
+---
+
+## Developer notes
+
+\`\`\`
+blocks/${blockName}/
+  ${blockName}.js       ← decorate() — add implementation here
+  ${blockName}.css      ← styles
+  _${blockName}.json    ← UE definitions, models, filters
+  README.md             ← this file
+\`\`\`
+
+**Local preview:**
+\`\`\`bash
+aem up
+# http://localhost:3000
+\`\`\`
+
+**After any JSON change:**
+\`\`\`bash
+npm run build:json && git add . && git commit -m "feat: update ${blockName}" && git push
+\`\`\`
+`;
+}
+
+// ─── Options builder (select / multiselect / radio-group / checkbox-group) ────
+async function collectOptions(rl, fieldName, ind = '') {
+  const options = [];
+  log.blank();
+  log.info(`Define options for ${c.bold}${fieldName}${c.reset}. Leave name blank to finish.`);
+  log.blank();
+
+  while (true) {
+    const name = (await prompt(rl, `${ind}  Option label (blank to finish): `)).trim();
+    if (!name) break;
+
+    // Auto-suggest a value from the label
+    const suggested = name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+    const raw = (await prompt(rl, `${ind}  Option value [${suggested}]: `)).trim();
+    const value = raw || suggested;
+
+    options.push({ name, value });
+    log.success(`  Option added: ${c.bold}${name}${c.reset} → ${c.dim}${value}${c.reset}`);
+    log.blank();
+  }
+
+  if (options.length === 0) {
+    options.push({ name: 'Option 1', value: 'option-1' }, { name: 'Option 2', value: 'option-2' });
+    log.warn('No options entered — added placeholders. Update them in component-models.json.');
+  }
+
+  log.info(`${options.length} option(s) defined for "${fieldName}".`);
+  log.blank();
+  return options;
+}
+
+// ─── Default value collector ──────────────────────────────────────────────────
+// Types that support a meaningful default value
+const DEFAULT_VALUE_TYPES = new Set([
+  'text', 'textarea', 'richtext', 'number', 'boolean',
+  'select', 'multiselect', 'radio-group', 'checkbox-group',
+  'date-time', 'aem-tag',
+]);
+
+async function collectDefaultValue(rl, field, ind = '') {
+  if (!DEFAULT_VALUE_TYPES.has(field.type)) return;
+
+  let question = '';
+
+  switch (field.type) {
+    case 'boolean':
+      question = `${ind}  Default value for "${field.name}" (true / false) [false]: `;
+      break;
+    case 'number':
+      question = `${ind}  Default number for "${field.name}" (Enter to skip): `;
+      break;
+    case 'select':
+    case 'radio-group': {
+      if (field.options?.length) {
+        const opts = field.options.map((o) => `${c.cyan}${o.value}${c.reset}`).join(' | ');
+        console.log(`\n  ${c.dim}Available values: ${opts}${c.reset}`);
+      }
+      question = `${ind}  Default selected value for "${field.name}" (Enter to skip): `;
+      break;
+    }
+    case 'multiselect':
+    case 'checkbox-group': {
+      if (field.options?.length) {
+        const opts = field.options.map((o) => `${c.cyan}${o.value}${c.reset}`).join(' | ');
+        console.log(`\n  ${c.dim}Available values: ${opts}${c.reset}`);
+      }
+      question = `${ind}  Default selected values for "${field.name}" (comma-separated, Enter to skip): `;
+      break;
+    }
+    case 'date-time':
+      question = `${ind}  Default date for "${field.name}" (YYYY-MM-DD, Enter to skip): `;
+      break;
+    default:
+      question = `${ind}  Default value for "${field.name}" (Enter to skip): `;
+  }
+
+  const raw = (await prompt(rl, question)).trim();
+  if (!raw) return;
+
+  // Validate boolean
+  if (field.type === 'boolean') {
+    field.defaultValue = raw === 'true' ? 'true' : 'false';
+    return;
+  }
+
+  // Validate number
+  if (field.type === 'number') {
+    if (isNaN(Number(raw))) {
+      log.warn(`"${raw}" is not a valid number — skipping default.`);
+      return;
+    }
+    const num = Number(raw);
+    if (field.min !== undefined && num < field.min) {
+      log.warn(`"${raw}" is below min:${field.min} — skipping default.`);
+      return;
+    }
+    if (field.max !== undefined && num > field.max) {
+      log.warn(`"${raw}" is above max:${field.max} — skipping default.`);
+      return;
+    }
+  }
+
+  // Validate select/radio must match one of the options
+  if ((field.type === 'select' || field.type === 'radio-group') && field.options?.length) {
+    const valid = field.options.map((o) => o.value);
+    if (!valid.includes(raw)) {
+      log.warn(`"${raw}" is not one of the defined option values — skipping default.`);
+      return;
+    }
+  }
+
+  // Validate multiselect/checkbox — each value must match an option
+  if ((field.type === 'multiselect' || field.type === 'checkbox-group') && field.options?.length) {
+    const valid  = new Set(field.options.map((o) => o.value));
+    const parts  = raw.split(',').map((s) => s.trim()).filter(Boolean);
+    const bad    = parts.filter((p) => !valid.has(p));
+    if (bad.length) {
+      log.warn(`Unknown option value(s): ${bad.join(', ')} — skipping default.`);
+      return;
+    }
+  }
+
+  field.defaultValue = raw;
+  log.info(`Default set: ${c.cyan}${raw}${c.reset}`);
+  log.blank();
+}
+
+// ─── Optional validation prompt ───────────────────────────────────────────────
+async function collectValidation(rl, field, indent = '') {
+  const available = VALIDATIONS[field.type] || [];
+  if (!available.length) return;
+  const hasExtras = await confirm(rl, `${indent}Add validation / hints for "${field.name}"?`, false);
+  if (!hasExtras) return;
+  log.blank();
+  if (available.includes('required'))    { if (await confirm(rl, `${indent}  Required?`, false)) field.required = true; }
+  if (available.includes('readOnly'))    { if (await confirm(rl, `${indent}  Read-only?`, false)) field.readOnly = true; }
+  if (available.includes('hidden'))      { if (await confirm(rl, `${indent}  Hidden?`, false)) field.hidden = true; }
+  if (available.includes('description')) { const d = (await prompt(rl, `${indent}  Helper text (Enter to skip): `)).trim(); if (d) field.description = d; }
+  if (available.includes('minLength'))   { const v = (await prompt(rl, `${indent}  Min length (Enter to skip): `)).trim(); if (v && !isNaN(v)) field.minLength = +v; }
+  if (available.includes('maxLength'))   { const v = (await prompt(rl, `${indent}  Max length (Enter to skip): `)).trim(); if (v && !isNaN(v)) field.maxLength = +v; }
+  if (available.includes('min'))         { const v = (await prompt(rl, `${indent}  Min${field.type === 'date-time' ? ' (YYYY-MM-DD)' : ''} (Enter to skip): `)).trim(); if (v) field.min = field.type === 'number' ? +v : v; }
+  if (available.includes('max'))         { const v = (await prompt(rl, `${indent}  Max${field.type === 'date-time' ? ' (YYYY-MM-DD)' : ''} (Enter to skip): `)).trim(); if (v) field.max = field.type === 'number' ? +v : v; }
+  if (available.includes('step'))        { const v = (await prompt(rl, `${indent}  Step (Enter to skip): `)).trim(); if (v && !isNaN(v)) field.step = +v; }
+  if (available.includes('rootPath'))    { const v = (await prompt(rl, `${indent}  Root path (Enter to skip): `)).trim(); if (v) field.rootPath = v; }
+  if (available.includes('customErrorMsg')) { const v = (await prompt(rl, `${indent}  Custom error message (Enter to skip): `)).trim(); if (v) field.customErrorMsg = v; }
+  log.blank();
+}
+
+// ─── Field collector ──────────────────────────────────────────────────────────
+async function collectFields(rl, context, depth = 0) {
+  const fields = [];
+  const ind    = depth > 0 ? '    ' : '';
+  log.info(`Define ${c.bold}${context}${c.reset} fields. Leave name blank to finish.`);
+  log.blank();
+
+  while (true) {
+    const name = (await prompt(rl, `${ind}Field name (camelCase, blank to finish): `)).trim();
+    if (!name) break;
+    if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(name)) { log.warn('camelCase only — no hyphens or underscores.'); continue; }
+
+    const defLabel = toTitleCase(name.replace(/([A-Z])/g, '-$1').toLowerCase());
+    const label    = (await prompt(rl, `${ind}Label for "${name}" [${defLabel}]: `)).trim() || defLabel;
+
+    printFieldTypes();
+    const typeIn = (await prompt(rl, `${ind}Type (name or number) [text]: `)).trim();
+    let type = 'text';
+    if (typeIn) { const byNum = ALL_FIELD_KEYS[parseInt(typeIn, 10) - 1]; type = byNum || (FIELD_TYPES[typeIn] ? typeIn : 'text'); }
+
+    const field = { name, label, type };
+
+    // multi: true option for eligible types
+    if (FIELD_TYPES[type]?.multi) {
+      const isMulti = await confirm(rl, `${ind}Allow multiple values (multi: true)?`, false);
+      if (isMulti) field.multi = true;
+    }
+
+    // Options builder for select / multiselect / radio-group / checkbox-group
+    if (OPTION_TYPES.has(type)) {
+      field.options = await collectOptions(rl, name, ind);
+    }
+
+    // Default value
+    await collectDefaultValue(rl, field, ind);
+
+    // Container — collect sub-fields
+    if (type === 'container') {
+      if (depth >= 1) {
+        log.warn('UE does not support nested containers — skipping sub-fields.');
+        field.subFields = [];
+      } else {
+        log.blank();
+        console.log(`  ${c.cyan}  ┌─ Container "${name}" — define sub-fields ─────────────────${c.reset}`);
+        field.subFields = await collectFields(rl, `${name} sub-fields`, depth + 1);
+        console.log(`  ${c.cyan}  └─ End of "${name}" ──────────────────────────────────────────${c.reset}`);
+        log.blank();
+      }
+    }
+
+    // Optional validation
+    await collectValidation(rl, field, ind);
+
+    fields.push(field);
+
+    // Summary
+    const extras = [
+      field.multi         && 'multi',
+      field.required      && 'required',
+      field.readOnly      && 'readOnly',
+      field.hidden        && 'hidden',
+      field.options       && `${field.options.length} options`,
+      field.defaultValue  !== undefined && `default:"${field.defaultValue}"`,
+      field.minLength     !== undefined && `minLen:${field.minLength}`,
+      field.maxLength     !== undefined && `maxLen:${field.maxLength}`,
+      field.min           !== undefined && `min:${field.min}`,
+      field.max           !== undefined && `max:${field.max}`,
+      field.step          !== undefined && `step:${field.step}`,
+      field.rootPath      && `rootPath:${field.rootPath}`,
+      field.description   && `hint:"${field.description}"`,
+    ].filter(Boolean);
+
+    if (type === 'container') {
+      log.success(`Added: ${c.bold}${name}${c.reset}  container  sub-fields: ${c.dim}${(field.subFields||[]).map((s)=>s.name).join(', ')||'none'}${c.reset}`);
+    } else {
+      log.success(`Added: ${c.bold}${name}${c.reset}  ${c.cyan}${type}${c.reset}${extras.length ? `  ${c.yellow}[${extras.join(', ')}]${c.reset}` : ''}`);
+    }
+    log.blank();
+  }
+
+  if (!fields.length && depth === 0) { fields.push({ name: 'text', label: 'Text', type: 'text' }); log.warn('No fields — defaulted to a single "text" field.'); }
+  return fields;
+}
+
+// ─── Consolidated block JSON writer ──────────────────────────────────────────
+// Generates a single blocks/<name>/_<name>.json containing
+// definitions, models and filters — matching the boilerplate pattern.
+// `npm run build:json` (merge-json-cli) assembles these into global files.
+
+function genBlockJSON(blockName, isContainer, parentFields, childName, childFields, needsVariants = false) {
+  // ── models ───────────────────────────────────────────────────────────────────
+  const models = [];
+  const parentSchema = buildFieldSchema(parentFields);
+
+  // classes field only added when author explicitly opted in during scaffolding
+  if (needsVariants) {
+    parentSchema.push({
+      component:  'text',
+      name:       'classes',
+      label:      'Variants (comma-separated)',
+      valueType:  'string',
+      value:      '',
+    });
+  }
+
+  models.push({ id: blockName, fields: parentSchema });
+  if (isContainer) {
+    models.push({ id: childName, fields: buildFieldSchema(childFields) });
+  }
+
+  // ── definitions ──────────────────────────────────────────────────────────────
+  const template = { name: toTitleCase(blockName), model: blockName };
+  if (isContainer) {
+    template.filter = blockName;
+    // No :items — pre-population causes 409 JCR conflict on insert
+  }
+
+  const definitions = [{
+    title: toTitleCase(blockName),
+    id:    blockName,
+    plugins: {
+      xwalk: {
+        page: {
+          resourceType: 'core/franklin/components/block/v1/block',
+          template,
+        },
+      },
+    },
+  }];
+
+  // Container blocks need a SECOND definition for the child item
+  // with resourceType block/item — this is what UE uses when author
+  // clicks + inside the block to add a child
+  if (isContainer) {
+    definitions.push({
+      title: toTitleCase(childName),
+      id:    childName,
+      plugins: {
+        xwalk: {
+          page: {
+            resourceType: 'core/franklin/components/block/v1/block/item',
+            template: {
+              name:  toTitleCase(childName),
+              model: childName,
+            },
+          },
+        },
+      },
+    });
+  }
+
+  // ── filters ──────────────────────────────────────────────────────────────────
+  // Section filter is NOT generated here — it is a project-level concern
+  // maintained in the boilerplate's central component-filters.json.
+  // Only the container filter is block-owned (restricts what goes inside this block).
+  const filters = [];
+  if (isContainer) {
+    filters.push({ id: blockName, components: [childName] });
+  }
+
+  return { definitions, models, filters };
+}
+
+function writeBlockJSON(blockDir, blockName, blockJSON, dryRun) {
+  const label   = `blocks/${blockName}/_${blockName}.json`;
+  const content = JSON.stringify(blockJSON, null, 2) + '\n';
+  writeFile(path.join(blockDir, `_${blockName}.json`), content, label, dryRun);
+}
+
+// ─── File writer (dry-run aware) ──────────────────────────────────────────────
+function writeFile(filePath, content, label, dryRun) {
+  if (!dryRun && fs.existsSync(filePath)) { log.warn(`${label} already exists — skipped.`); return; }
+  if (dryRun) {
+    log.dry(`Would create: ${label}`);
+    console.log(`\n${c.dim}${'─'.repeat(60)}${c.reset}`);
+    content.split('\n').slice(0, 20).forEach((l) => console.log(`  ${c.dim}${l}${c.reset}`));
+    if (content.split('\n').length > 20) console.log(`  ${c.dim}... (${content.split('\n').length - 20} more lines)${c.reset}`);
+    console.log(`${c.dim}${'─'.repeat(60)}${c.reset}\n`);
+    return;
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, 'utf8');
+  log.success(`Created  ${label}`);
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// COMMAND: create
+// ══════════════════════════════════════════════════════════════════════════════
+async function cmdCreate(rl, cwd, argName, dryRun) {
+  if (dryRun) log.warn('DRY RUN — no files will be written.\n');
+
+  let blockName = argName;
+  if (!blockName) {
+    blockName = (await prompt(rl, `Block name (kebab-case): `)).trim().toLowerCase().replace(/\s+/g, '-');
+  }
+  if (!blockName || !isValidName(blockName)) { log.error('Invalid block name.'); rl.close(); process.exit(1); }
+
+  log.divider();
+  log.info(`Block: ${c.bold}${blockName}${c.reset}`);
+  log.info(`Dir  : ${c.dim}${cwd}${c.reset}`);
+  log.divider();
+
+  // Block type
+  log.blank();
+  console.log(`  ${c.bold}Block type:${c.reset}`);
+  console.log(`    ${c.dim}1.${c.reset} ${c.cyan}Simple${c.reset}     ${c.dim}Fixed fields — hero, banner, teaser, quote${c.reset}`);
+  console.log(`    ${c.dim}2.${c.reset} ${c.cyan}Multi-row${c.reset}  ${c.dim}Same fields repeating — slider, cards, table rows${c.reset}`);
+  console.log(`    ${c.dim}3.${c.reset} ${c.cyan}Container${c.reset}  ${c.dim}Children with different fields — accordion, tabs${c.reset}`);
+  log.blank();
+  const typeIn = (await prompt(rl, `Type [1]: `)).trim();
+  const isContainer = typeIn === '3' || typeIn.toLowerCase() === 'container';
+  const isMultiRow  = typeIn === '2' || typeIn.toLowerCase() === 'multi-row';
+  log.blank();
+
+  // Parent fields
+  log.section(isContainer ? `Phase 1 — Parent config fields` : `Define block fields`);
+  const parentFields = await collectFields(rl, isContainer ? `${blockName} config` : blockName);
+
+  // Container: child setup
+  let childName = '', childFields = [];
+  if (isContainer) {
+    log.divider();
+    log.section(`Phase 2 — Child item`);
+    const sugg    = `${blockName}-item`;
+    const childIn = (await prompt(rl, `Child item name [${sugg}]: `)).trim().toLowerCase().replace(/\s+/g, '-');
+    childName     = childIn || sugg;
+    if (!isValidName(childName)) { log.error(`Invalid child name.`); rl.close(); process.exit(1); }
+    log.blank();
+    log.info(`Child: ${c.bold}${childName}${c.reset}`);
+    log.blank();
+    childFields = await collectFields(rl, `${childName} fields`);
+  }
+
+  // Variants prompt — asked for all block types
+  log.divider();
+  const needsVariants = await confirm(rl, `Does this block need variants? ${c.dim}(e.g. dark, light, compact)${c.reset}`, false);
+  if (needsVariants) {
+    log.info(`Variants enabled — a ${c.cyan}classes${c.reset} field will be added to the model.`);
+    log.info(`Authors type variant names in UE → they apply as CSS classes on the block.`);
+  }
+  log.blank();
+
+  rl.close();
+
+  // Write files
+  log.blank(); log.divider(); log.blank();
+
+  const dir = path.join(cwd, 'blocks', blockName);
+
+  // Minimal lint-free JS based on block type
+  let jsContent;
+  if (isContainer)     jsContent = genContainerBlockJS(blockName, childName);
+  else if (isMultiRow) jsContent = genMultiRowBlockJS(blockName);
+  else                 jsContent = genSimpleBlockJS(blockName);
+
+  writeFile(path.join(dir, `${blockName}.js`),  jsContent,              `blocks/${blockName}/${blockName}.js`,  dryRun);
+  writeFile(path.join(dir, `${blockName}.css`), genBlockCSS(blockName), `blocks/${blockName}/${blockName}.css`, dryRun);
+  writeFile(path.join(dir, 'README.md'), genReadme(blockName, isContainer, parentFields, childName, childFields, needsVariants), `blocks/${blockName}/README.md`, dryRun);
+
+  const blockJSON = genBlockJSON(blockName, isContainer, parentFields, childName, childFields, needsVariants);
+  writeBlockJSON(dir, blockName, blockJSON, dryRun);
+
+  // Summary
+  log.blank(); log.divider();
+  const prefix   = dryRun ? `${c.yellow}~ DRY RUN${c.reset} ` : `${c.green}✔${c.reset} `;
+  const typeLabel = isContainer ? `container → ${childName}` : isMultiRow ? 'multi-row' : 'simple';
+  console.log(`\n  ${prefix}${c.bold}"${blockName}" ${dryRun ? 'would be' : 'scaffolded!'} (${typeLabel})${c.reset}\n`);
+  if (!dryRun) {
+    console.log(`  ${c.dim}Files created:${c.reset}`);
+    console.log(`    ${c.cyan}blocks/${blockName}/${blockName}.js${c.reset}`);
+    console.log(`    ${c.cyan}blocks/${blockName}/${blockName}.css${c.reset}`);
+    console.log(`    ${c.cyan}blocks/${blockName}/README.md${c.reset}`);
+    console.log(`    ${c.cyan}blocks/${blockName}/_${blockName}.json${c.reset}  ${c.dim}(definitions + models + filters)${c.reset}`);
+    console.log(`\n  ${c.dim}Next steps:${c.reset}`);
+    console.log(`    1. Add ${c.bold}"${blockName}"${c.reset} to the ${c.cyan}section${c.reset} entry in your project's ${c.bold}component-filters.json${c.reset}`);
+    console.log(`    2. ${c.bold}npm run build:json${c.reset} → assemble global JSON files`);
+    console.log(`    3. ${c.bold}aem up${c.reset} → http://localhost:3000`);
+    console.log(`    4. Add block in Universal Editor`);
+    console.log(`    5. Implement ${c.bold}blocks/${blockName}/${blockName}.js${c.reset}\n`);
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// COMMAND: remove
+// ══════════════════════════════════════════════════════════════════════════════
+async function cmdRemove(rl, cwd, blockName, dryRun) {
+  log.title('Remove Block');
+  if (!blockName) { blockName = (await prompt(rl, `Block name to remove: `)).trim().toLowerCase(); }
+  if (!isValidName(blockName)) { log.error('Invalid block name.'); rl.close(); process.exit(1); }
+
+  const blockDir = path.join(cwd, 'blocks', blockName);
+  if (!fs.existsSync(blockDir)) { log.error(`blocks/${blockName}/ does not exist.`); rl.close(); process.exit(1); }
+
+  if (!dryRun) {
+    log.warn(`This will delete blocks/${blockName}/ including all JS, CSS, README and block-level JSON files.`);
+    const ok = await confirm(rl, 'Are you sure?', false);
+    if (!ok) { log.info('Cancelled.'); rl.close(); return; }
+  }
+
+  rl.close();
+  log.divider();
+
+  if (dryRun) {
+    const files = fs.readdirSync(blockDir).map((f) => `blocks/${blockName}/${f}`);
+    log.dry(`Would delete blocks/${blockName}/ (${files.length} file(s)):`);
+    files.forEach((f) => console.log(`  ${c.dim}  ${f}${c.reset}`));
+  } else {
+    fs.rmSync(blockDir, { recursive: true, force: true });
+    log.success(`Deleted  blocks/${blockName}/`);
+  }
+
+  log.blank();
+  log.info(`Run ${c.bold}npm run build:json${c.reset} to rebuild the global JSON files.`);
+  log.blank();
+  dryRun ? log.dry('Dry run complete — nothing deleted.') : log.success(`"${blockName}" removed.`);
+  log.blank();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// COMMAND: list
+// ══════════════════════════════════════════════════════════════════════════════
+function cmdList(cwd) {
+  log.title('Block Inventory');
+
+  const blocksDir = path.join(cwd, 'blocks');
+  if (!fs.existsSync(blocksDir)) { log.warn('No blocks/ directory found.'); return; }
+
+  const blocks = fs.readdirSync(blocksDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  if (!blocks.length) { log.info('No blocks found.'); return; }
+
+  // Header
+  console.log(`\n  ${c.bold}${col('Block', 26)} JS   CSS  JSON   README${c.reset}`);
+  log.divider();
+
+  let issues = 0;
+  blocks.forEach((name) => {
+    const dir    = path.join(blocksDir, name);
+    const hasJS  = fs.existsSync(path.join(dir, `${name}.js`));
+    const hasCSS = fs.existsSync(path.join(dir, `${name}.css`));
+    const hasJSON = fs.existsSync(path.join(dir, `_${name}.json`));
+    const hasRM  = fs.existsSync(path.join(dir, 'README.md'));
+    const allGood = hasJS && hasCSS && hasJSON;
+    if (!allGood) issues++;
+    const nameColor = allGood ? c.reset : c.yellow;
+    console.log(`  ${nameColor}${col(name, 26)}${c.reset} ${tick(hasJS)}    ${tick(hasCSS)}   ${tick(hasJSON)}    ${tick(hasRM)}`);
+  });
+
+  log.blank();
+  log.info(`${blocks.length} block(s) found${issues ? `  ${c.yellow}(${issues} with issues)${c.reset}` : `  ${c.green}(all clean)${c.reset}`}`);
+  log.info(`Run ${c.bold}npm run build:json${c.reset} to rebuild global component-*.json files`);
+  log.blank();
+}
+
+// ─── Help ──────────────────────────────────────────────────────────────────────
+function printHelp() {
+  console.log(`
+  ${c.bold}${c.cyan}AEM EDS Block Scaffolder${c.reset}
+
+  ${c.bold}Usage:${c.reset}
+    npx eds-block-scaffold <command> [block-name] [flags]
+
+  ${c.bold}Commands:${c.reset}
+    ${c.cyan}create${c.reset} [name]   Scaffold a new block  ${c.dim}(default if no command given)${c.reset}
+    ${c.cyan}remove${c.reset} <name>   Delete block folder (JSON files go with it)
+    ${c.cyan}list${c.reset}            Show all blocks with file & authoring JSON status
+
+  ${c.bold}Flags:${c.reset}
+    ${c.cyan}--dry-run${c.reset}       Preview what would be generated without writing files
+
+  ${c.bold}Block-level JSON pattern:${c.reset}
+    Each block owns a single consolidated JSON file — no global file edits.
+    Run ${c.bold}npm run build:json${c.reset} (boilerplate script) to assemble globals.
+
+    blocks/<name>/
+      <name>.js              ← decoration logic
+      <name>.css             ← styles
+      _<name>.json           ← definitions + models + filters (all in one)
+      README.md              ← authoring guide
+
+  ${c.bold}Examples:${c.reset}
+    npx eds-block-scaffold create
+    npx eds-block-scaffold create carousel
+    npx eds-block-scaffold create carousel --dry-run
+    npx eds-block-scaffold remove old-block
+    npx eds-block-scaffold list
+`);
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// ENTRY POINT
+// ══════════════════════════════════════════════════════════════════════════════
+async function main() {
+  const args    = process.argv.slice(2);
+  const dryRun  = args.includes('--dry-run');
+  const cleaned = args.filter((a) => !a.startsWith('--'));
+  const cmd     = cleaned[0] || 'create';
+  const arg1    = cleaned[1] || '';
+  const cwd     = process.cwd();
+
+  if (cmd === 'help' || cmd === '--help' || cmd === '-h') { printHelp(); process.exit(0); }
+
+  log.title('AEM EDS Block Scaffolder');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  process.on('SIGINT', () => { log.blank(); log.info('Cancelled.'); rl.close(); process.exit(0); });
+
+  if (cmd === 'list') { rl.close(); cmdList(cwd); }
+  else if (cmd === 'remove' || cmd === 'delete') { await cmdRemove(rl, cwd, arg1, dryRun); }
+  else if (cmd === 'create' || isValidName(cmd)) {
+    const blockName = isValidName(cmd) && cmd !== 'create' ? cmd : arg1;
+    await cmdCreate(rl, cwd, blockName, dryRun);
+  } else {
+    log.error(`Unknown command: "${cmd}"`);
+    printHelp();
+    rl.close();
+    process.exit(1);
+  }
+}
+
+main().catch((err) => { log.error(err.message); process.exit(1); });

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "aem-eds-cli",
+  "version": "1.0.0",
+  "description": "CLI scaffolding tool for AEM Edge delivery services blocks with Universal editor authoring support",
+  "bin": {
+    "aem-eds-cli": "./bin/aem-eds.js"
+  },
+  "keywords": ["aem", "eds", "cli", "scaffolding", "tool","adobe", "experience", "manager", "edge", "delivery", "services", "blocks", "universal", "editor", "authoring"],
+  "license": "Apache-2.0",
+  "author":"Arkaprava Majumder<arkmajumder@deloitte.com>",
+  "engines": {"node":">=16"},
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ]
+}