@uniformdev/transformer 1.1.8 → 1.1.10

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -900,7 +900,7 @@ var PatternAnalyzerService = class {
     this.logger = logger;
   }
   async analyze(options) {
-    const { rootDir, compositionsDir, projectMapNodesDir, minGroupSize, depth, threshold } = options;
+    const { rootDir, compositionsDir, projectMapNodesDir, minGroupSize, depth, threshold, subset } = options;
     const compositionsPath = this.fileSystem.resolvePath(rootDir, compositionsDir);
     const projectMapNodesPath = this.fileSystem.resolvePath(rootDir, projectMapNodesDir);
     const projectMapNodes = await this.loadProjectMapNodes(projectMapNodesPath);
@@ -926,7 +926,9 @@ var PatternAnalyzerService = class {
       }
     }
     let groups;
-    if (threshold === 0) {
+    if (subset) {
+      groups = this.clusterBySubset(loadedCompositions, depth);
+    } else if (threshold === 0) {
       const fingerprintGroups = /* @__PURE__ */ new Map();
       for (const item of loadedCompositions) {
         if (!fingerprintGroups.has(item.fingerprint)) {
@@ -960,34 +962,77 @@ var PatternAnalyzerService = class {
         }
         continue;
       }
-      group.sort((a, b) => {
-        const idA = a.composition.composition._id ?? "";
-        const idB = b.composition.composition._id ?? "";
-        return idA.localeCompare(idB);
-      });
-      const firstComposition = group[0].composition;
-      const rootType = firstComposition.composition.type;
-      const firstName = this.getCompositionName(firstComposition);
-      rootTypeCounts.set(rootType, (rootTypeCounts.get(rootType) ?? 0) + 1);
-      const structureDescription = this.generateStructureDescription(firstComposition);
-      const compositions = group.map(({ composition, filePath }) => ({
-        id: composition.composition._id ?? "unknown",
-        name: this.getCompositionName(composition),
-        projectMapNodeSlug: this.resolveProjectMapSlug(composition, projectMapNodes),
-        filePath
-      }));
-      const fingerprint = group[0].fingerprint;
-      const patternGroup = {
-        name: rootType,
-        // Temporary name, will be updated below if disambiguation needed
-        structureDescription,
-        fingerprint,
-        compositions,
-        _rootType: rootType,
-        _firstName: firstName
-      };
-      patterns.push(patternGroup);
-      patternCompositionsData.set(patternGroup, group.map((g) => g.composition));
+      if (subset) {
+        const nodeCache = /* @__PURE__ */ new Map();
+        for (const item of group) {
+          const id = item.composition.composition._id ?? "";
+          nodeCache.set(id, this.parseCompositionToNode(item.composition, depth));
+        }
+        group.sort((a, b) => {
+          const idA = a.composition.composition._id ?? "";
+          const idB = b.composition.composition._id ?? "";
+          const countA = this.countNodes(nodeCache.get(idA));
+          const countB = this.countNodes(nodeCache.get(idB));
+          if (countB !== countA) return countB - countA;
+          return idA.localeCompare(idB);
+        });
+        let mergedNode = nodeCache.get(group[0].composition.composition._id ?? "");
+        for (let i = 1; i < group.length; i++) {
+          const id = group[i].composition.composition._id ?? "";
+          mergedNode = this.mergeComponentNodes(mergedNode, nodeCache.get(id));
+        }
+        const firstComposition = group[0].composition;
+        const rootType = firstComposition.composition.type;
+        const firstName = this.getCompositionName(firstComposition);
+        rootTypeCounts.set(rootType, (rootTypeCounts.get(rootType) ?? 0) + 1);
+        const structureDescription = this.generateStructureDescriptionFromNode(mergedNode);
+        const compositions = group.map(({ composition, filePath }) => ({
+          id: composition.composition._id ?? "unknown",
+          name: this.getCompositionName(composition),
+          projectMapNodeSlug: this.resolveProjectMapSlug(composition, projectMapNodes),
+          filePath
+        }));
+        const fingerprint = group[0].fingerprint;
+        const patternGroup = {
+          name: rootType,
+          structureDescription,
+          fingerprint,
+          compositions,
+          _rootType: rootType,
+          _firstName: firstName
+        };
+        patterns.push(patternGroup);
+        patternCompositionsData.set(patternGroup, group.map((g) => g.composition));
+      } else {
+        group.sort((a, b) => {
+          const idA = a.composition.composition._id ?? "";
+          const idB = b.composition.composition._id ?? "";
+          return idA.localeCompare(idB);
+        });
+        const firstComposition = group[0].composition;
+        const rootType = firstComposition.composition.type;
+        const firstName = this.getCompositionName(firstComposition);
+        rootTypeCounts.set(rootType, (rootTypeCounts.get(rootType) ?? 0) + 1);
+        const structureDescription = this.generateStructureDescription(firstComposition);
+        const compositions = group.map(({ composition, filePath }) => ({
+          id: composition.composition._id ?? "unknown",
+          name: this.getCompositionName(composition),
+          projectMapNodeSlug: this.resolveProjectMapSlug(composition, projectMapNodes),
+          filePath
+        }));
+        const fingerprint = group[0].fingerprint;
+        const patternGroup = {
+          name: rootType,
+          // Temporary name, will be updated below if disambiguation needed
+          structureDescription,
+          fingerprint,
+          compositions,
+          _rootType: rootType,
+          _firstName: firstName
+        };
+        patterns.push(patternGroup);
+        patternCompositionsData.set(patternGroup, group.map((g) => g.composition));
+      }
     }
     for (const pattern of patterns) {
       const p = pattern;
@@ -1137,6 +1182,158 @@ var PatternAnalyzerService = class {
     }
     return distance;
   }
+  /**
+   * Checks if `smaller` is a structural subset of `larger`.
+   * Same root type required. For each slot in `smaller`, that slot must exist
+   * in `larger` with at least the same components at the same positions.
+   * `larger` may have extra slots or extra trailing components. Recursive.
+   */
+  isSubsetOf(smaller, larger) {
+    if (smaller.type !== larger.type) {
+      return false;
+    }
+    for (const [slotName, smallerChildren] of smaller.slots) {
+      const largerChildren = larger.slots.get(slotName);
+      if (!largerChildren) {
+        return false;
+      }
+      if (smallerChildren.length > largerChildren.length) {
+        return false;
+      }
+      for (let i = 0; i < smallerChildren.length; i++) {
+        if (!this.isSubsetOf(smallerChildren[i], largerChildren[i])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Counts total component instances in a tree (root + all descendants).
+   */
+  countNodes(node) {
+    let count = 1;
+    for (const children of node.slots.values()) {
+      for (const child of children) {
+        count += this.countNodes(child);
+      }
+    }
+    return count;
+  }
+  /**
+   * Merges two ComponentNode trees into a combined superset structure.
+   * Takes the union of all slots and the maximum components at each position.
+   * Both nodes must have the same root type.
+   */
+  mergeComponentNodes(a, b) {
+    if (a.type !== b.type) {
+      return a;
+    }
+    const mergedSlots = /* @__PURE__ */ new Map();
+    const allSlotNames = /* @__PURE__ */ new Set([...a.slots.keys(), ...b.slots.keys()]);
+    for (const slotName of allSlotNames) {
+      const aChildren = a.slots.get(slotName) ?? [];
+      const bChildren = b.slots.get(slotName) ?? [];
+      const maxLen = Math.max(aChildren.length, bChildren.length);
+      const mergedChildren = [];
+      for (let i = 0; i < maxLen; i++) {
+        const aChild = aChildren[i];
+        const bChild = bChildren[i];
+        if (aChild && bChild) {
+          if (aChild.type === bChild.type) {
+            mergedChildren.push(this.mergeComponentNodes(aChild, bChild));
+          } else {
+            mergedChildren.push(this.countNodes(aChild) >= this.countNodes(bChild) ? aChild : bChild);
+          }
+        } else {
+          mergedChildren.push(aChild ?? bChild);
+        }
+      }
+      mergedSlots.set(slotName, mergedChildren);
+    }
+    return { type: a.type, slots: mergedSlots };
+  }
+  /**
+   * Clusters compositions using Union-Find based on subset relationship.
+   * Two compositions are unioned if either is a structural subset of the other.
+   */
+  clusterBySubset(compositions, depth) {
+    const n = compositions.length;
+    if (n === 0) return [];
+    const parsedNodes = compositions.map(
+      (item) => this.parseCompositionToNode(item.composition, depth)
+    );
+    const parent = Array.from({ length: n }, (_, i) => i);
+    const rank = Array(n).fill(0);
+    const find = (x) => {
+      if (parent[x] !== x) {
+        parent[x] = find(parent[x]);
+      }
+      return parent[x];
+    };
+    const union = (x, y) => {
+      const rootX = find(x);
+      const rootY = find(y);
+      if (rootX !== rootY) {
+        if (rank[rootX] < rank[rootY]) {
+          parent[rootX] = rootY;
+        } else if (rank[rootX] > rank[rootY]) {
+          parent[rootY] = rootX;
+        } else {
+          parent[rootY] = rootX;
+          rank[rootX]++;
+        }
+      }
+    };
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        if (parsedNodes[i].type !== parsedNodes[j].type) {
+          continue;
+        }
+        if (this.isSubsetOf(parsedNodes[i], parsedNodes[j]) || this.isSubsetOf(parsedNodes[j], parsedNodes[i])) {
+          union(i, j);
+        }
+      }
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (let i = 0; i < n; i++) {
+      const root = find(i);
+      if (!groups.has(root)) {
+        groups.set(root, []);
+      }
+      groups.get(root).push(compositions[i]);
+    }
+    return Array.from(groups.values());
+  }
+  /**
+   * Generates a structure description from a ComponentNode tree (instead of a Composition).
+   */
+  generateStructureDescriptionFromNode(node) {
+    return this.generateNodeDescriptionFromNode(node, 0);
+  }
+  generateNodeDescriptionFromNode(node, depth) {
+    if (node.slots.size === 0) {
+      return node.type;
+    }
+    const sortedSlotNames = [...node.slots.keys()].sort();
+    const slotDescriptions = sortedSlotNames.map((slotName) => {
+      const children = node.slots.get(slotName);
+      if (children.length === 0) {
+        return null;
+      }
+      const instanceTypes = children.map((child) => {
+        if (child.slots.size > 0) {
+          return this.generateNodeDescriptionFromNode(child, depth + 1);
+        }
+        return child.type;
+      });
+      return `${slotName}[${instanceTypes.join(", ")}]`;
+    }).filter(Boolean);
+    if (slotDescriptions.length === 0) {
+      return node.type;
+    }
+    return `${node.type} > ${slotDescriptions.join(" > ")}`;
+  }
   /**
    * Extracts all unique component types from a composition recursively.
    */
@@ -1586,7 +1783,7 @@ function createFindCompositionPatternCandidatesCommand() {
     "--threshold <count>",
     "Number of component differences allowed while still matching (0 = exact match)",
     "0"
-  ).option("--format <format>", "Output format: text or json", "text").option("--brief", "Skip structure and composition details in text output").hook("preAction", (thisCommand) => {
+  ).option("--format <format>", "Output format: text or json", "text").option("--brief", "Skip structure and composition details in text output").option("--subset", "Group compositions where one structure is a subset of another", false).hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const minGroupSize = parseInt(opts.minGroupSize, 10);
     if (isNaN(minGroupSize) || minGroupSize < 2) {
@@ -1615,7 +1812,8 @@ function createFindCompositionPatternCandidatesCommand() {
       depth: parseInt(opts.depth, 10),
       threshold: parseInt(opts.threshold, 10),
       format: opts.format,
-      brief: opts.brief ?? false
+      brief: opts.brief ?? false,
+      subset: opts.subset ?? false
     };
     const logger = new Logger();
     const fileSystem = new FileSystemService();
@@ -1630,7 +1828,8 @@ function createFindCompositionPatternCandidatesCommand() {
         minGroupSize: options.minGroupSize,
         depth: options.depth,
         threshold: options.threshold,
-        strict: options.strict ?? false
+        strict: options.strict ?? false,
+        subset: options.subset ?? false
       });
       if (options.format === "json") {
         console.log(analyzer.formatJsonOutput(result));
@@ -3375,10 +3574,425 @@ function createPropagateRootComponentSlotCommand() {
   return command;
 }
 
+// src/cli/commands/convert-compositions-to-entries.ts
+import { Command as Command10 } from "commander";
+
+// src/core/services/composition-converter.service.ts
+import * as crypto from "crypto";
+var CompositionConverterService = class {
+  constructor(fileSystem, componentService, compositionService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.compositionService = compositionService;
+    this.logger = logger;
+  }
+  async convert(options) {
+    const {
+      rootDir,
+      compositionsDir,
+      componentsDir,
+      contentTypesDir,
+      entriesDir,
+      compositionTypes,
+      flattenComponentIds,
+      whatIf,
+      strict
+    } = options;
+    const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
+    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
+    let contentTypesWritten = 0;
+    let entriesFromCompositions = 0;
+    let entriesFromFlattened = 0;
+    this.logger.info(`Composition types: ${compositionTypes.join(", ")}`);
+    if (flattenComponentIds.length > 0) {
+      this.logger.info(`Flatten component types: ${flattenComponentIds.join(", ")}`);
+    }
+    const compositionResults = await this.compositionService.findCompositionsByTypes(
+      compositionsDirFull,
+      compositionTypes,
+      { strict }
+    );
+    if (compositionResults.length === 0) {
+      this.logger.warn("No compositions found matching the specified types");
+      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromFlattened: 0 };
+    }
+    this.logger.info(`Found ${compositionResults.length} composition(s)`);
+    const rootComponentTypes = /* @__PURE__ */ new Set();
+    for (const { composition } of compositionResults) {
+      rootComponentTypes.add(composition.composition.type);
+    }
+    const contentTypeMap = /* @__PURE__ */ new Map();
+    for (const rootType of rootComponentTypes) {
+      const { component } = await this.componentService.loadComponent(
+        componentsDirFull,
+        rootType,
+        { strict }
+      );
+      const contentType = this.generateContentType(component);
+      contentTypeMap.set(rootType, contentType);
+    }
+    const flattenContentTypeMap = /* @__PURE__ */ new Map();
+    for (const flattenType of flattenComponentIds) {
+      const isRootType = [...rootComponentTypes].some(
+        (rt) => this.compareTypes(rt, flattenType, strict)
+      );
+      if (isRootType) {
+        continue;
+      }
+      try {
+        const { component } = await this.componentService.loadComponent(
+          componentsDirFull,
+          flattenType,
+          { strict }
+        );
+        const contentType = this.generateContentType(component);
+        flattenContentTypeMap.set(flattenType, contentType);
+      } catch (error) {
+        if (error instanceof ComponentNotFoundError) {
+          throw new ComponentNotFoundError(flattenType, componentsDirFull);
+        }
+        throw error;
+      }
+    }
+    if (flattenComponentIds.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const flattenType of flattenComponentIds) {
+          if (this.compareTypes(flattenType, contentType.id, strict)) {
+            continue;
+          }
+          contentType.fields.push({
+            id: flattenType,
+            name: flattenType,
+            type: "contentReference",
+            typeConfig: {
+              isMulti: true,
+              allowedContentTypes: [flattenType]
+            },
+            localizable: false
+          });
+        }
+      }
+    }
+    for (const [typeName, contentType] of contentTypeMap) {
+      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
+      const fieldCount = contentType.fields.filter((f) => f.type !== "contentReference").length;
+      const refCount = contentType.fields.filter((f) => f.type === "contentReference").length;
+      const refInfo = refCount > 0 ? ` + ${refCount} reference(s)` : "";
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${contentTypesDir}/${typeName}.json (${fieldCount} fields${refInfo})`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(filePath, contentType);
+      }
+      contentTypesWritten++;
+    }
+    for (const [typeName, contentType] of flattenContentTypeMap) {
+      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(filePath, contentType);
+      }
+      contentTypesWritten++;
+    }
+    for (const { composition } of compositionResults) {
+      const comp = composition.composition;
+      const compositionId = comp._id;
+      const compositionName = comp._name ?? compositionId;
+      const compositionType = comp.type;
+      const entry = this.generateEntryFromComposition(composition);
+      const flattenedByType = /* @__PURE__ */ new Map();
+      if (flattenComponentIds.length > 0 && comp.slots) {
+        for (const flattenType of flattenComponentIds) {
+          if (this.compareTypes(flattenType, compositionType, strict)) {
+            this.logger.warn(
+              `Skipping flatten of "${flattenType}" \u2014 same as root component type`
+            );
+            continue;
+          }
+          const instances = this.findFlattenTargets(
+            comp.slots,
+            flattenType,
+            compositionId,
+            compositionName,
+            strict
+          );
+          if (instances.length > 0) {
+            flattenedByType.set(flattenType, instances);
+          }
+        }
+      }
+      for (const [flattenType, instances] of flattenedByType) {
+        entry.entry.fields[flattenType] = {
+          type: "contentReference",
+          value: instances.map((inst) => inst.determinisiticId)
+        };
+      }
+      const entryFilePath = this.fileSystem.joinPath(entriesDirFull, `${compositionId}.json`);
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${entriesDir}/${compositionId}.json (${compositionType}, "${this.truncate(compositionName, 50)}")`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(entryFilePath, entry);
+      }
+      entriesFromCompositions++;
+      for (const [flattenType, instances] of flattenedByType) {
+        for (const inst of instances) {
+          const flatEntry = this.generateEntryFromFlattenedInstance(inst);
+          const flatEntryPath = this.fileSystem.joinPath(
+            entriesDirFull,
+            `${inst.determinisiticId}.json`
+          );
+          this.logger.action(
+            whatIf,
+            "WRITE",
+            `${entriesDir}/${inst.determinisiticId}.json (${flattenType} from "${this.truncate(compositionName, 50)}")`
+          );
+          if (!whatIf) {
+            await this.fileSystem.writeFile(flatEntryPath, flatEntry);
+          }
+          entriesFromFlattened++;
+        }
+      }
+    }
+    return { contentTypesWritten, entriesFromCompositions, entriesFromFlattened };
+  }
+  // --- Content Type Generation ---
+  generateContentType(component) {
+    const fields = [];
+    if (component.parameters) {
+      for (const param of component.parameters) {
+        fields.push(this.parameterToField(param));
+      }
+    }
+    return {
+      id: component.id,
+      name: component.name,
+      fields
+    };
+  }
+  parameterToField(param) {
+    const field = {
+      id: param.id,
+      name: param.name,
+      type: param.type
+    };
+    if (param.helpText !== void 0) {
+      field.helpText = param.helpText;
+    }
+    if (param.localizable !== void 0) {
+      field.localizable = param.localizable;
+    }
+    if (param.typeConfig !== void 0) {
+      field.typeConfig = param.typeConfig;
+    }
+    return field;
+  }
+  // --- Entry Generation ---
+  generateEntryFromComposition(composition) {
+    const comp = composition.composition;
+    return {
+      entry: {
+        _id: comp._id,
+        _name: comp._name ?? comp._id,
+        type: comp.type,
+        fields: { ...comp.parameters ?? {} }
+      }
+    };
+  }
+  generateEntryFromFlattenedInstance(inst) {
+    return {
+      entry: {
+        _id: inst.determinisiticId,
+        _name: `${inst.componentType} (from ${inst.compositionName})`,
+        type: inst.componentType,
+        fields: { ...inst.instance.parameters ?? {} }
+      }
+    };
+  }
+  // --- Flatten Tree Walking ---
+  findFlattenTargets(slots, targetType, compositionId, compositionName, strict) {
+    const results = [];
+    this.walkSlots(slots, targetType, compositionId, compositionName, "", results, strict);
+    return results;
+  }
+  walkSlots(slots, targetType, compositionId, compositionName, pathPrefix, results, strict) {
+    for (const [slotName, instances] of Object.entries(slots)) {
+      if (!Array.isArray(instances)) continue;
+      for (let i = 0; i < instances.length; i++) {
+        const instance = instances[i];
+        if (instance._pattern) {
+          continue;
+        }
+        const currentPath = pathPrefix ? `${pathPrefix}-${slotName}-[${i}]-${instance.type}` : `${slotName}-[${i}]-${instance.type}`;
+        if (this.compareTypes(instance.type, targetType, strict)) {
+          const fullPath = `${compositionId}-${currentPath}`;
+          const deterministicId = computeGuidHash(fullPath);
+          results.push({
+            instance,
+            path: fullPath,
+            determinisiticId: deterministicId,
+            componentType: instance.type,
+            compositionId,
+            compositionName
+          });
+        }
+        if (instance.slots) {
+          this.walkSlots(
+            instance.slots,
+            targetType,
+            compositionId,
+            compositionName,
+            currentPath,
+            results,
+            strict
+          );
+        }
+      }
+    }
+  }
+  // --- Utilities ---
+  compareTypes(type1, type2, strict) {
+    if (strict) {
+      return type1 === type2;
+    }
+    return type1.toLowerCase() === type2.toLowerCase();
+  }
+  truncate(str, maxLength) {
+    if (str.length <= maxLength) return str;
+    return str.substring(0, maxLength - 3) + "...";
+  }
+};
+function computeGuidHash(guidOrSeed) {
+  let uuidStr;
+  if (isValidUuid(guidOrSeed)) {
+    uuidStr = formatAsBracedUuid(guidOrSeed);
+  } else {
+    const hash = crypto.createHash("md5").update(guidOrSeed, "utf-8").digest();
+    const hex = [
+      // First 4 bytes: little-endian in .NET Guid
+      hash[3].toString(16).padStart(2, "0"),
+      hash[2].toString(16).padStart(2, "0"),
+      hash[1].toString(16).padStart(2, "0"),
+      hash[0].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 4-5: little-endian
+      hash[5].toString(16).padStart(2, "0"),
+      hash[4].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 6-7: little-endian
+      hash[7].toString(16).padStart(2, "0"),
+      hash[6].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 8-9: big-endian
+      hash[8].toString(16).padStart(2, "0"),
+      hash[9].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 10-15: big-endian
+      hash[10].toString(16).padStart(2, "0"),
+      hash[11].toString(16).padStart(2, "0"),
+      hash[12].toString(16).padStart(2, "0"),
+      hash[13].toString(16).padStart(2, "0"),
+      hash[14].toString(16).padStart(2, "0"),
+      hash[15].toString(16).padStart(2, "0")
+    ].join("");
+    uuidStr = `{${hex}}`.toUpperCase();
+  }
+  const chars = uuidStr.split("");
+  chars[15] = "4";
+  const arr20 = ["8", "9", "A", "B"];
+  const hexVal = parseInt(chars[20], 16);
+  chars[20] = arr20[hexVal % 4];
+  return chars.join("").slice(1, -1).toLowerCase();
+}
+function isValidUuid(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+}
+function formatAsBracedUuid(uuid) {
+  const clean = uuid.replace(/[{}]/g, "").toUpperCase();
+  return `{${clean}}`;
+}
+
+// src/cli/commands/convert-compositions-to-entries.ts
+function createConvertCompositionsToEntriesCommand() {
+  const command = new Command10("convert-compositions-to-entries");
+  command.description(
+    "Converts compositions into content entries, optionally flattening nested components into separate referenced entries."
+  ).option(
+    "--compositionTypes <types>",
+    "Pipe-separated list of composition types to convert (e.g., ProductDetailPage|ArticlePage)"
+  ).option(
+    "--flattenComponentIds <types>",
+    "Pipe-separated list of component types to flatten into separate entries (e.g., DetailHero|ArticleDetail)"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "compositionTypes", flag: "--compositionTypes" }
+    ];
+    const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
+    if (missing.length > 0) {
+      console.error(`error: missing required options: ${missing.join(", ")}`);
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      compositionTypes: opts.compositionTypes,
+      flattenComponentIds: opts.flattenComponentIds
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const compositionService = new CompositionService(fileSystem);
+    const converter = new CompositionConverterService(
+      fileSystem,
+      componentService,
+      compositionService,
+      logger
+    );
+    try {
+      const compositionTypes = options.compositionTypes.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
+      const flattenComponentIds = options.flattenComponentIds ? options.flattenComponentIds.split("|").map((t) => t.trim()).filter((t) => t.length > 0) : [];
+      const result = await converter.convert({
+        rootDir: options.rootDir,
+        compositionsDir: options.compositionsDir,
+        componentsDir: options.componentsDir,
+        contentTypesDir: options.contentTypesDir,
+        entriesDir: options.entriesDir,
+        compositionTypes,
+        flattenComponentIds,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      const flatInfo = result.entriesFromFlattened > 0 ? `, ${result.entriesFromFlattened} from flattened components` : "";
+      logger.success(
+        `${result.contentTypesWritten} content type(s), ${result.entriesFromCompositions} entry(ies) from compositions${flatInfo}`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.8",
+  version: "1.1.10",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -3447,7 +4061,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command10();
+var program = new Command11();
 var appVersion = package_default.version;
 console.error(`uniform-transform v${appVersion}`);
 program.name("uniform-transform").description("CLI tool for transforming Uniform.dev serialization files offline").version(appVersion);
@@ -3469,5 +4083,6 @@ program.addCommand(createRenameComponentCommand());
 program.addCommand(createAddComponentCommand());
 program.addCommand(createAddComponentPatternCommand());
 program.addCommand(createPropagateRootComponentSlotCommand());
+program.addCommand(createConvertCompositionsToEntriesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map