@uniformdev/transformer 1.1.34 → 1.1.36

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -659,6 +659,7 @@ var CompositionConverterService = class {
         );
         const contentType = this.generateContentType(component);
         contentTypeMap.set(rootType, contentType);
+        this.logger.debug(`Generated content type "${rootType}" with ${contentType.fields.length} field(s): ${contentType.fields.map((f) => f.id).join(", ")}`);
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
           this.logger.warn(`Component not found: ${rootType} \u2014 skipping content type generation`);
@@ -694,6 +695,7 @@ var CompositionConverterService = class {
         if (isRefType) {
           const contentType = this.generateContentType(component);
           targetContentTypeMap.set(targetType, contentType);
+          this.logger.debug(`Generated reference content type "${targetType}" with ${contentType.fields.length} field(s): ${contentType.fields.map((f) => f.id).join(", ")}`);
         }
         if (isBlockType) {
           let blockId = targetType;
@@ -723,6 +725,7 @@ var CompositionConverterService = class {
           blockContentType.id = blockId;
           blockContentType.name = needsRename ? `${blockContentType.name} Block` : blockContentType.name;
           targetContentTypeMap.set(blockId, blockContentType);
+          this.logger.debug(`Generated block content type "${blockId}" with ${blockContentType.fields.length} field(s): ${blockContentType.fields.map((f) => f.id).join(", ")}`);
         }
         if (!isBlockType) {
           if (!isRefType) {
@@ -764,6 +767,7 @@ var CompositionConverterService = class {
         }
       } else {
         entry = this.generateEntryFromComposition(composition);
+        this.logger.debug(`Generated entry "${entry.entry._id}" from composition "${compositionName}" (${compositionType}) with fields: ${Object.keys(entry.entry.fields).join(", ") || "(none)"}`);
       }
       const refsByType = /* @__PURE__ */ new Map();
       if (componentsToReferences.length > 0 && comp.slots) {
@@ -781,6 +785,7 @@ var CompositionConverterService = class {
             compositionName,
             strict
           );
+          this.logger.debug(`Composition "${compositionName}": found ${instances.length} instance(s) of reference type "${refType}"`);
           if (instances.length > 0) {
             refsByType.set(refType, instances);
             if (missingTargetTypes.includes(refType)) {
@@ -794,6 +799,7 @@ var CompositionConverterService = class {
         const refIds = [];
         for (const inst of instances) {
           const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          this.logger.debug(`Reference instance "${inst.determinisiticId}" (${refType}): ${existingId ? `reusing existing entry "${existingId}"` : `assigned new ID "${inst.determinisiticId}"`}`);
           refIds.push(existingId ?? inst.determinisiticId);
         }
         resolvedRefIds.set(refType, refIds);
@@ -823,6 +829,7 @@ var CompositionConverterService = class {
             compositionName,
             strict
           );
+          this.logger.debug(`Composition "${compositionName}": found ${instances.length} instance(s) of block type "${blockType}"`);
           if (instances.length > 0) {
             blocksByType.set(blockType, instances);
             if (missingTargetTypes.includes(blockType)) {
@@ -879,6 +886,7 @@ var CompositionConverterService = class {
               "UPDATE",
               `${entriesDir}/${existingId}.json (${refType}, merged fields from "${this.truncate(compositionName, 50)}")`
             );
+            this.logger.debug(`Merging fields [${Object.keys(inst.instance.parameters ?? {}).join(", ") || "(none)"}] into existing reference entry "${existingId}"`);
             if (!whatIf) {
               const existingEntry = await this.fileSystem.readFile(existingEntryPath2);
               if (existingEntry?.entry) {
@@ -903,6 +911,7 @@ var CompositionConverterService = class {
             "WRITE",
             `${entriesDir}/${inst.determinisiticId}.json (${refType} from "${this.truncate(compositionName, 50)}")`
           );
+          this.logger.debug(`Writing reference entry "${inst.determinisiticId}" (${refType}) with fields: ${Object.keys(flatEntry.entry.fields).join(", ") || "(none)"}`);
           if (!whatIf) {
             await this.fileSystem.writeFile(flatEntryPath, flatEntry);
           }
@@ -929,6 +938,7 @@ var CompositionConverterService = class {
             },
             localizable: false
           });
+          this.logger.debug(`Field "${refType}" (contentReference) added to content type "${contentType.id}"`);
         }
       }
     }
@@ -951,6 +961,7 @@ var CompositionConverterService = class {
             },
             localizable: false
           });
+          this.logger.debug(`Field "${resolvedBlockId}" ($block) added to content type "${contentType.id}"`);
         }
       }
     }
@@ -975,6 +986,7 @@ var CompositionConverterService = class {
         "WRITE",
         `${contentTypesDir}/${typeName}.json (${baseFieldCount} fields${extrasInfo})`
       );
+      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
         await this.fileSystem.writeFile(filePath, contentType);
       }
@@ -987,6 +999,7 @@ var CompositionConverterService = class {
         "WRITE",
         `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
       );
+      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
         await this.fileSystem.writeFile(filePath, contentType);
       }
@@ -1352,6 +1365,7 @@ var PropertyPropagatorService = class {
       try {
         const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
         sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
+        this.logger.debug(`Loaded source component "${sourceType}" from ${sourceFilePath}`);
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
           this.logger.warn(`Component not found: ${sourceType} (searched: ${fullComponentsDir})`);
@@ -1362,6 +1376,7 @@ var PropertyPropagatorService = class {
     }
     this.logger.info(`Loading component: ${targetComponentType}`);
     const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
+    this.logger.debug(`Loaded target component "${targetComponentType}" from ${targetFilePath}`);
     const propertyNames = property.split("|").map((p) => p.trim()).filter((p) => p.length > 0);
     const resolvedParams = [];
     const resolvedNames = [];
@@ -1382,6 +1397,8 @@ var PropertyPropagatorService = class {
         if (!exists) {
           resolvedParams.push(param);
           resolvedNames.push(param.id);
+        } else {
+          this.logger.debug(`Parameter "${param.id}" already collected from another source \u2014 skipping duplicate`);
         }
       }
     }
@@ -1420,7 +1437,10 @@ var PropertyPropagatorService = class {
         targetGroup,
         findOptions
       );
+      this.logger.debug(`Group "${targetGroup}" (id: ${groupId}) created on component ${targetComponentType}`);
       componentModified = true;
+    } else {
+      this.logger.debug(`Group "${targetGroup}" (id: ${groupId}) already exists on ${targetComponentType}`);
     }
     for (const param of resolvedParams) {
       const existingParam = this.componentService.findParameter(
@@ -1445,6 +1465,7 @@ var PropertyPropagatorService = class {
           param.id,
           findOptions
         );
+        this.logger.debug(`Parameter "${param.id}" (type: ${param.type}) added to component ${targetComponentType} in group "${targetGroup}"`);
         componentModified = true;
       } else {
         this.logger.info(`Parameter "${param.id}" already exists on ${targetComponentType}`);
@@ -1464,7 +1485,10 @@ var PropertyPropagatorService = class {
               param.id,
               findOptions
             );
+            this.logger.debug(`Parameter "${param.id}" added to group "${targetGroup}" on ${targetComponentType} (was missing from group)`);
             componentModified = true;
+          } else {
+            this.logger.debug(`Parameter "${param.id}" already in group "${targetGroup}" on ${targetComponentType} \u2014 no change`);
           }
         }
       }
@@ -1477,6 +1501,7 @@ var PropertyPropagatorService = class {
       compositionTypes,
       findOptions
     );
+    this.logger.debug(`Found ${compositions.length} composition(s) matching types [${compositionTypes.join(", ")}]`);
     let modifiedCompositions = 0;
     let propagatedInstances = 0;
     for (const { composition, filePath } of compositions) {
@@ -1487,6 +1512,7 @@ var PropertyPropagatorService = class {
         findOptions
       );
       if (instances.length === 0) {
+        this.logger.debug(`Skipping "${filePath}": no instances of ${targetComponentType} found`);
         continue;
       }
       const valuesToPropagate = {};
@@ -1496,6 +1522,7 @@ var PropertyPropagatorService = class {
         }
       }
       if (Object.keys(valuesToPropagate).length === 0) {
+        this.logger.debug(`Skipping "${filePath}": ${instances.length} instance(s) of ${targetComponentType} found but none of [${resolvedNames.join(", ")}] present in root overrides`);
         continue;
       }
       let compositionModified = false;
@@ -1507,9 +1534,11 @@ var PropertyPropagatorService = class {
         this.compositionService.setInstanceParameters(instance, clonedValues);
         compositionModified = true;
         propagatedInstances++;
+        const updatedParamNames = Object.keys(valuesToPropagate).join(", ");
         instanceUpdates.push(
-          `${targetComponentType} "${instanceName}": ${Object.keys(valuesToPropagate).join(", ")}`
+          `${targetComponentType} "${instanceName}": ${updatedParamNames}`
         );
+        this.logger.debug(`Component ${targetComponentType} "${instanceName}": parameters ${updatedParamNames} updated`);
       }
       if (compositionModified) {
         this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
@@ -1532,7 +1561,10 @@ var PropertyPropagatorService = class {
           if (exists) {
             this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${sourceType}`);
             modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
+            this.logger.debug(`Parameter "${param.id}" removed from component ${sourceType}`);
             sourceComponentModified = true;
+          } else {
+            this.logger.debug(`Parameter "${param.id}" not found on source component "${sourceType}" \u2014 nothing to delete`);
           }
         }
         const beforeGroupCount = modifiedSource.parameters?.filter(
@@ -1571,6 +1603,8 @@ var PropertyPropagatorService = class {
           if (!whatIf) {
             await this.compositionService.saveComposition(filePath, composition);
           }
+        } else {
+          this.logger.debug(`No root overrides matching [${resolvedNames.join(", ")}] in composition/${relativePath}`);
         }
       }
     }
@@ -1598,9 +1632,16 @@ var PropertyPropagatorService = class {
 // src/cli/logger.ts
 import chalk from "chalk";
 var Logger = class {
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
   info(message) {
     console.log(`${chalk.blue("[INFO]")} ${message}`);
   }
+  debug(message) {
+    if (!this.verbose) return;
+    console.log(`${chalk.magenta("[DEBUG]")} ${message}`);
+  }
   success(message) {
     console.log(`${chalk.green("[DONE]")} ${message}`);
   }
@@ -1636,7 +1677,7 @@ function createPropagateRootComponentPropertyCommand() {
   ).option(
     "--deleteSourceParameter",
     "Delete the original parameters from the source component after propagation"
-  ).hook("preAction", (thisCommand) => {
+  ).option("--verbose", "Enable verbose output with detailed progress information").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
       { name: "compositionType", flag: "--compositionType" },
@@ -1659,7 +1700,7 @@ function createPropagateRootComponentPropertyCommand() {
       targetGroup: opts.targetGroup,
       deleteSourceParameter: opts.deleteSourceParameter
     };
-    const logger = new Logger();
+    const logger = new Logger(opts.verbose ?? false);
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const compositionService = new CompositionService(fileSystem);
@@ -1686,6 +1727,10 @@ function createPropagateRootComponentPropertyCommand() {
         `Modified ${result.modifiedComponents} component, ${result.modifiedCompositions} compositions`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -3215,6 +3260,10 @@ function createRenameSlotCommand() {
         `Renamed slot: ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -3492,6 +3541,10 @@ function createRenameComponentCommand() {
         `Renamed component: ${result.allowedComponentsUpdated} allowedComponents ref(s), ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -3603,16 +3656,7 @@ var ComponentAdderService = class {
       throw new TransformError("parentComponentType cannot be empty");
     }
     this.logger.info(`Validating new component: ${newComponentType}`);
-    try {
-      await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
-    } catch (error) {
-      if (error instanceof ComponentNotFoundError) {
-        throw new TransformError(
-          `Component type "${newComponentType}" not found in ${fullComponentsDir}`
-        );
-      }
-      throw error;
-    }
+    await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
     let allowedComponentsUpdated = false;
     const resolvedParentTypes = [];
     for (const parentType of parentTypes) {
@@ -4042,6 +4086,10 @@ function createAddComponentCommand() {
         `Added component: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4097,6 +4145,10 @@ function createAddComponentPatternCommand() {
         `Added component pattern: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4407,6 +4459,10 @@ function createPropagateRootComponentSlotCommand() {
         `Modified ${result.modifiedComponents} component(s), ${result.modifiedCompositions} composition(s)`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4432,7 +4488,7 @@ function createConvertCompositionsToEntriesCommand() {
   ).option(
     "--componentsToBlocks <types>",
     "Pipe-separated list of component types to convert into inline blocks (e.g., DetailHero|ArticleDetail)"
-  ).hook("preAction", (thisCommand) => {
+  ).option("--verbose", "Enable verbose output with detailed progress information").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
       { name: "compositionTypes", flag: "--compositionTypes" }
@@ -4450,7 +4506,7 @@ function createConvertCompositionsToEntriesCommand() {
       componentsToReferences: opts.componentsToReferences,
       componentsToBlocks: opts.componentsToBlocks
     };
-    const logger = new Logger();
+    const logger = new Logger(opts.verbose ?? false);
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const compositionService = new CompositionService(fileSystem);
@@ -4484,6 +4540,10 @@ function createConvertCompositionsToEntriesCommand() {
         `${result.contentTypesWritten} content type(s), ${result.entriesFromCompositions} entry(ies) from compositions${refInfo}${reusedInfo}${blocksInfo}`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4811,7 +4871,7 @@ function createRemoveParameterCommand() {
           aggregate.compositionPatternsModified += result.compositionPatternsModified;
           aggregate.componentPatternsModified += result.componentPatternsModified;
         } catch (error) {
-          if (hasWildcard && (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError)) {
+          if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
             logger.warn(error.message);
             continue;
           }
@@ -5254,6 +5314,10 @@ function createAddComponentParameterCommand() {
         `${result.parameterReplaced ? "Replaced" : "Added"} parameter "${options.parameterId}" on component "${options.componentId}"`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -5832,6 +5896,10 @@ function createFlattenBlockFieldCommand() {
         `Flattened parameter "${options.parameterId}" on component "${options.componentId}": ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -5842,10 +5910,171 @@ function createFlattenBlockFieldCommand() {
   return command;
 }
 
+// src/cli/commands/remove-orphan-entries.ts
+import { Command as Command16 } from "commander";
+
+// src/core/services/orphan-entry-remover.service.ts
+var OrphanEntryRemoverService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async remove(options) {
+    const { rootDir, entriesDir, rootContentTypes, whatIf, strict } = options;
+    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
+    const dirExists = await this.fileSystem.fileExists(entriesDirFull);
+    if (!dirExists) {
+      this.logger.warn(`Entries directory not found: ${entriesDir} \u2014 nothing to do`);
+      return { totalEntries: 0, whitelistedEntries: 0, removedEntries: 0 };
+    }
+    const entryFiles = await this.fileSystem.findFiles(entriesDirFull, "**/*.{json,yaml,yml}");
+    if (entryFiles.length === 0) {
+      this.logger.warn("No entry files found \u2014 nothing to do");
+      return { totalEntries: 0, whitelistedEntries: 0, removedEntries: 0 };
+    }
+    this.logger.info(`Loaded ${entryFiles.length} entry file(s)`);
+    const entryMap = /* @__PURE__ */ new Map();
+    for (const filePath of entryFiles) {
+      let entryData;
+      try {
+        entryData = await this.fileSystem.readFile(filePath);
+      } catch {
+        this.logger.warn(`Could not read entry file: ${filePath} \u2014 skipping`);
+        continue;
+      }
+      if (!entryData?.entry?._id) {
+        this.logger.warn(`Entry file missing entry._id: ${filePath} \u2014 skipping`);
+        continue;
+      }
+      entryMap.set(entryData.entry._id, { filePath, entryData });
+    }
+    this.logger.info(`Root content types: ${rootContentTypes.join(", ")}`);
+    const whitelist = /* @__PURE__ */ new Set();
+    for (const [entryId, { entryData }] of entryMap) {
+      if (this.matchesContentType(entryData.entry.type, rootContentTypes, strict)) {
+        whitelist.add(entryId);
+      }
+    }
+    this.logger.info(`Whitelisted ${whitelist.size} entry(ies) from root content types`);
+    let round = 0;
+    let frontier = [...whitelist];
+    while (frontier.length > 0) {
+      round++;
+      const nextFrontier = [];
+      for (const entryId of frontier) {
+        const entry = entryMap.get(entryId);
+        if (!entry) continue;
+        const referencedIds = this.extractReferencedEntryIds(entry.entryData);
+        for (const refId of referencedIds) {
+          if (!whitelist.has(refId) && entryMap.has(refId)) {
+            whitelist.add(refId);
+            nextFrontier.push(refId);
+          }
+        }
+      }
+      if (nextFrontier.length > 0) {
+        this.logger.info(`BFS round ${round}: added ${nextFrontier.length} entry(ies) via references`);
+      }
+      frontier = nextFrontier;
+    }
+    this.logger.info(`BFS stable after ${round} round(s)`);
+    let removedEntries = 0;
+    for (const [entryId, { filePath, entryData }] of entryMap) {
+      if (!whitelist.has(entryId)) {
+        const relPath = this.fileSystem.joinPath(entriesDir, this.fileSystem.getBasename(filePath));
+        this.logger.action(whatIf, "DELETE", `${relPath} (${entryData.entry.type})`);
+        if (!whatIf) {
+          this.fileSystem.deleteFile(filePath);
+        }
+        removedEntries++;
+      }
+    }
+    return {
+      totalEntries: entryMap.size,
+      whitelistedEntries: whitelist.size,
+      removedEntries
+    };
+  }
+  extractReferencedEntryIds(entryData) {
+    const ids = [];
+    if (entryData.entry._dataResources) {
+      for (const resource of Object.values(entryData.entry._dataResources)) {
+        if (resource.type === "uniformContentInternalReference" && resource.variables?.entryIds) {
+          const entryIds = resource.variables.entryIds.split(",").map((s) => s.trim()).filter(Boolean);
+          ids.push(...entryIds);
+        }
+      }
+    }
+    if (entryData.entry.fields) {
+      for (const field of Object.values(entryData.entry.fields)) {
+        if (field.type === "contentReference" && Array.isArray(field.value)) {
+          for (const id of field.value) {
+            if (typeof id === "string") {
+              ids.push(id);
+            }
+          }
+        }
+      }
+    }
+    return ids;
+  }
+  matchesContentType(entryType, rootContentTypes, strict) {
+    for (const rootType of rootContentTypes) {
+      if (strict) {
+        if (entryType === rootType) return true;
+      } else {
+        if (entryType.toLowerCase() === rootType.toLowerCase()) return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/cli/commands/remove-orphan-entries.ts
+function createRemoveOrphanEntriesCommand() {
+  const command = new Command16("remove-orphan-entries");
+  command.description(
+    "Removes entry files that are not reachable from root content-type entries by following contentReference links transitively."
+  ).option(
+    "--rootContentTypes <types>",
+    'Pipe-separated list of content-type IDs whose entries are treated as roots and never deleted (e.g. "HomePage|BlogPost")'
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [{ name: "rootContentTypes", flag: "--rootContentTypes" }];
+    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,
+      rootContentTypes: opts.rootContentTypes
+    };
+    const logger = new Logger();
+    logger.info(`rootContentTypes: ${options.rootContentTypes}`);
+    const rootContentTypes = options.rootContentTypes.split("|").map((t) => t.trim()).filter(Boolean);
+    const fileSystem = new FileSystemService();
+    const service = new OrphanEntryRemoverService(fileSystem, logger);
+    const result = await service.remove({
+      rootDir: options.rootDir,
+      entriesDir: options.entriesDir,
+      rootContentTypes,
+      whatIf: options.whatIf ?? false,
+      strict: options.strict ?? false
+    });
+    logger.success(
+      `Removed ${result.removedEntries} orphan entry(ies). ${result.whitelistedEntries} entry(ies) retained.`
+    );
+  });
+  return command;
+}
+
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.34",
+  version: "1.1.36",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -5914,7 +6143,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command16();
+var program = new Command17();
 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);
@@ -5942,5 +6171,6 @@ program.addCommand(createRemoveFieldCommand());
 program.addCommand(createAddComponentParameterCommand());
 program.addCommand(createAddContentTypeFieldCommand());
 program.addCommand(createFlattenBlockFieldCommand());
+program.addCommand(createRemoveOrphanEntriesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map