@uniformdev/transformer 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,2399 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command7 } from "commander";
+
+// src/cli/commands/propagate-root-component-property.ts
+import { Command } from "commander";
+
+// src/core/services/file-system.service.ts
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+import * as YAML from "yaml";
+
+// src/core/errors.ts
+var TransformError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TransformError";
+  }
+};
+var ComponentNotFoundError = class extends TransformError {
+  constructor(componentType, path2) {
+    const pathInfo = path2 ? ` (searched: ${path2})` : "";
+    super(`Component not found: ${componentType}${pathInfo}`);
+    this.name = "ComponentNotFoundError";
+  }
+};
+var PropertyNotFoundError = class extends TransformError {
+  constructor(propertyName, componentType) {
+    super(`Property "${propertyName}" not found on component "${componentType}"`);
+    this.name = "PropertyNotFoundError";
+  }
+};
+var InvalidYamlError = class extends TransformError {
+  constructor(filePath, details) {
+    const detailsInfo = details ? `: ${details}` : "";
+    super(`Invalid YAML file: ${filePath}${detailsInfo}`);
+    this.name = "InvalidYamlError";
+  }
+};
+var FileNotFoundError = class extends TransformError {
+  constructor(filePath) {
+    super(`File not found: ${filePath}`);
+    this.name = "FileNotFoundError";
+  }
+};
+var DuplicateIdError = class extends TransformError {
+  constructor(id, arrayProperty, filePath) {
+    super(`Duplicate id "${id}" in array "${arrayProperty}" of file: ${filePath}`);
+    this.name = "DuplicateIdError";
+  }
+};
+var ComponentAlreadyExistsError = class extends TransformError {
+  constructor(componentType, path2) {
+    const pathInfo = path2 ? ` (searched: ${path2})` : "";
+    super(`Component type "${componentType}" already exists${pathInfo}`);
+    this.name = "ComponentAlreadyExistsError";
+  }
+};
+var SlotNotFoundError = class extends TransformError {
+  constructor(slotId, componentType) {
+    super(`Slot "${slotId}" does not exist on component "${componentType}"`);
+    this.name = "SlotNotFoundError";
+  }
+};
+var SlotAlreadyExistsError = class extends TransformError {
+  constructor(slotId, componentType) {
+    super(`Slot "${slotId}" already exists on component "${componentType}"`);
+    this.name = "SlotAlreadyExistsError";
+  }
+};
+
+// src/core/services/file-system.service.ts
+var FileSystemService = class {
+  isJsonFile(filePath) {
+    return filePath.toLowerCase().endsWith(".json");
+  }
+  async readFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new FileNotFoundError(filePath);
+    }
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      if (this.isJsonFile(filePath)) {
+        return JSON.parse(content);
+      }
+      return YAML.parse(content);
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new InvalidYamlError(filePath, message);
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    let content;
+    if (this.isJsonFile(filePath)) {
+      content = JSON.stringify(data, null, 2);
+    } else {
+      content = YAML.stringify(data, {
+        lineWidth: 0,
+        defaultKeyType: "PLAIN",
+        defaultStringType: "QUOTE_DOUBLE"
+      });
+    }
+    fs.writeFileSync(filePath, content, "utf-8");
+  }
+  async readYamlFile(filePath) {
+    return this.readFile(filePath);
+  }
+  async writeYamlFile(filePath, data) {
+    return this.writeFile(filePath, data);
+  }
+  async findFiles(directory, pattern) {
+    const fullPattern = path.join(directory, pattern).replace(/\\/g, "/");
+    return glob(fullPattern);
+  }
+  async fileExists(filePath) {
+    return fs.existsSync(filePath);
+  }
+  resolvePath(...segments) {
+    return path.resolve(...segments);
+  }
+  joinPath(...segments) {
+    return path.join(...segments);
+  }
+  getBasename(filePath, ext) {
+    return path.basename(filePath, ext);
+  }
+  async renameFile(oldPath, newPath) {
+    fs.renameSync(oldPath, newPath);
+  }
+  deleteFile(filePath) {
+    fs.unlinkSync(filePath);
+  }
+  getExtension(filePath) {
+    return path.extname(filePath);
+  }
+  getDirname(filePath) {
+    return path.dirname(filePath);
+  }
+};
+
+// src/core/services/component.service.ts
+var ComponentService = class {
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async loadComponent(componentsDir, componentType, options = {}) {
+    const { strict = false } = options;
+    const jsonPath = this.fileSystem.joinPath(componentsDir, `${componentType}.json`);
+    const yamlPath = this.fileSystem.joinPath(componentsDir, `${componentType}.yaml`);
+    const ymlPath = this.fileSystem.joinPath(componentsDir, `${componentType}.yml`);
+    if (await this.fileSystem.fileExists(jsonPath)) {
+      const component = await this.fileSystem.readFile(jsonPath);
+      return { component, filePath: jsonPath };
+    }
+    if (await this.fileSystem.fileExists(yamlPath)) {
+      const component = await this.fileSystem.readFile(yamlPath);
+      return { component, filePath: yamlPath };
+    }
+    if (await this.fileSystem.fileExists(ymlPath)) {
+      const component = await this.fileSystem.readFile(ymlPath);
+      return { component, filePath: ymlPath };
+    }
+    if (!strict) {
+      const files = await this.fileSystem.findFiles(componentsDir, "*.{json,yaml,yml}");
+      for (const filePath of files) {
+        const basename2 = this.fileSystem.getBasename(filePath);
+        const nameWithoutExt = basename2.replace(/\.(json|yaml|yml)$/i, "");
+        if (nameWithoutExt.toLowerCase() === componentType.toLowerCase()) {
+          const component = await this.fileSystem.readFile(filePath);
+          return { component, filePath };
+        }
+      }
+    }
+    throw new ComponentNotFoundError(componentType, componentsDir);
+  }
+  async saveComponent(filePath, component) {
+    await this.fileSystem.writeFile(filePath, component);
+  }
+  findParameter(component, parameterName, options = {}) {
+    const { strict = false } = options;
+    return component.parameters?.find((p) => this.compareIds(p.id, parameterName, strict));
+  }
+  isGroupParameter(parameter) {
+    return parameter.type === "group";
+  }
+  resolveGroupParameters(component, groupParameter, options = {}) {
+    if (!this.isGroupParameter(groupParameter)) {
+      return [groupParameter];
+    }
+    const childrenIds = groupParameter.typeConfig?.childrenParams ?? [];
+    const resolved = [];
+    for (const childId of childrenIds) {
+      const childParam = this.findParameter(component, childId, options);
+      if (childParam) {
+        resolved.push(childParam);
+      }
+    }
+    return resolved;
+  }
+  resolveProperties(component, propertyNames, options = {}) {
+    const parameters = [];
+    const notFound = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const name of propertyNames) {
+      const param = this.findParameter(component, name, options);
+      if (!param) {
+        notFound.push(name);
+        continue;
+      }
+      if (this.isGroupParameter(param)) {
+        const groupParams = this.resolveGroupParameters(component, param, options);
+        for (const gp of groupParams) {
+          if (!seenIds.has(gp.id)) {
+            seenIds.add(gp.id);
+            parameters.push(gp);
+          }
+        }
+      } else {
+        if (!seenIds.has(param.id)) {
+          seenIds.add(param.id);
+          parameters.push(param);
+        }
+      }
+    }
+    return { parameters, notFound };
+  }
+  addParameterToComponent(component, parameter, options = {}) {
+    const { strict = false } = options;
+    if (!component.parameters) {
+      component.parameters = [];
+    }
+    const existingIndex = component.parameters.findIndex(
+      (p) => this.compareIds(p.id, parameter.id, strict)
+    );
+    if (existingIndex >= 0) {
+      component.parameters[existingIndex] = { ...parameter };
+    } else {
+      component.parameters.push({ ...parameter });
+    }
+    return component;
+  }
+  ensureGroupExists(component, groupId, groupName, options = {}) {
+    const { strict = false } = options;
+    if (!component.parameters) {
+      component.parameters = [];
+    }
+    const existing = component.parameters.find((p) => this.compareIds(p.id, groupId, strict));
+    if (existing) {
+      return component;
+    }
+    const groupParam = {
+      id: groupId,
+      name: groupName ?? groupId,
+      type: "group",
+      typeConfig: {
+        childrenParams: []
+      }
+    };
+    component.parameters.push(groupParam);
+    return component;
+  }
+  addParameterToGroup(component, groupId, parameterId, options = {}) {
+    const { strict = false } = options;
+    const group = component.parameters?.find((p) => this.compareIds(p.id, groupId, strict));
+    if (!group || !this.isGroupParameter(group)) {
+      throw new PropertyNotFoundError(groupId, component.id);
+    }
+    if (!group.typeConfig) {
+      group.typeConfig = { childrenParams: [] };
+    }
+    if (!group.typeConfig.childrenParams) {
+      group.typeConfig.childrenParams = [];
+    }
+    const alreadyExists = group.typeConfig.childrenParams.some(
+      (id) => this.compareIds(id, parameterId, strict)
+    );
+    if (!alreadyExists) {
+      group.typeConfig.childrenParams.push(parameterId);
+    }
+    return component;
+  }
+  removeParameter(component, parameterId, options = {}) {
+    const { strict = false } = options;
+    if (!component.parameters) {
+      return component;
+    }
+    component.parameters = component.parameters.filter(
+      (p) => !this.compareIds(p.id, parameterId, strict)
+    );
+    for (const param of component.parameters) {
+      if (this.isGroupParameter(param) && param.typeConfig?.childrenParams) {
+        param.typeConfig.childrenParams = param.typeConfig.childrenParams.filter(
+          (id) => !this.compareIds(id, parameterId, strict)
+        );
+      }
+    }
+    return component;
+  }
+  removeEmptyGroups(component) {
+    if (!component.parameters) {
+      return component;
+    }
+    component.parameters = component.parameters.filter((p) => {
+      if (!this.isGroupParameter(p)) {
+        return true;
+      }
+      const children = p.typeConfig?.childrenParams ?? [];
+      return children.length > 0;
+    });
+    return component;
+  }
+};
+
+// src/core/services/composition.service.ts
+var CompositionService = class {
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  compareTypes(type1, type2, strict) {
+    if (strict) {
+      return type1 === type2;
+    }
+    return type1.toLowerCase() === type2.toLowerCase();
+  }
+  async loadComposition(filePath) {
+    return this.fileSystem.readFile(filePath);
+  }
+  async saveComposition(filePath, composition) {
+    await this.fileSystem.writeFile(filePath, composition);
+  }
+  async findCompositionsByType(compositionsDir, compositionType, options = {}) {
+    const { strict = false } = options;
+    const files = await this.fileSystem.findFiles(compositionsDir, "**/*.{json,yaml,yml}");
+    const results = [];
+    for (const filePath of files) {
+      try {
+        const composition = await this.loadComposition(filePath);
+        if (composition.composition?.type && this.compareTypes(composition.composition.type, compositionType, strict)) {
+          results.push({ composition, filePath });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  findComponentInstances(composition, componentType, options = {}) {
+    const { strict = false } = options;
+    const results = [];
+    this.searchSlots(composition.composition.slots ?? {}, componentType, [], results, strict);
+    return results;
+  }
+  searchSlots(slots, componentType, currentPath, 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];
+        const instancePath = [...currentPath, slotName, String(i)];
+        if (this.compareTypes(instance.type, componentType, strict)) {
+          const instanceId = instance._id ?? `${componentType}-${results.length}`;
+          results.push({
+            instance,
+            instanceId,
+            path: instancePath
+          });
+        }
+        if (instance.slots) {
+          this.searchSlots(instance.slots, componentType, instancePath, results, strict);
+        }
+      }
+    }
+  }
+  getRootOverrides(composition) {
+    const rootId = composition.composition._id;
+    const overrides = composition.composition._overrides?.[rootId]?.parameters;
+    if (overrides && Object.keys(overrides).length > 0) {
+      return overrides;
+    }
+    return composition.composition.parameters ?? {};
+  }
+  getInstanceOverrides(composition, instanceId) {
+    return composition.composition._overrides?.[instanceId]?.parameters ?? {};
+  }
+  setInstanceOverride(composition, instanceId, parameterId, value) {
+    if (!composition.composition._overrides) {
+      composition.composition._overrides = {};
+    }
+    if (!composition.composition._overrides[instanceId]) {
+      composition.composition._overrides[instanceId] = {};
+    }
+    if (!composition.composition._overrides[instanceId].parameters) {
+      composition.composition._overrides[instanceId].parameters = {};
+    }
+    composition.composition._overrides[instanceId].parameters[parameterId] = value;
+    return composition;
+  }
+  setInstanceOverrides(composition, instanceId, parameters) {
+    for (const [paramId, value] of Object.entries(parameters)) {
+      this.setInstanceOverride(composition, instanceId, paramId, value);
+    }
+    return composition;
+  }
+  /**
+   * Sets parameters directly on a component instance (preferred approach).
+   * This modifies the instance object in-place.
+   */
+  setInstanceParameters(instance, parameters) {
+    if (!instance.parameters) {
+      instance.parameters = {};
+    }
+    for (const [paramId, value] of Object.entries(parameters)) {
+      instance.parameters[paramId] = value;
+    }
+  }
+  /**
+   * Deletes parameters from root overrides.
+   * Returns true if any parameters were deleted.
+   */
+  deleteRootOverrides(composition, parameterIds, options = {}) {
+    const { strict = false } = options;
+    const rootId = composition.composition._id;
+    let deleted = false;
+    const overrides = composition.composition._overrides?.[rootId]?.parameters;
+    if (overrides) {
+      for (const paramId of parameterIds) {
+        for (const key of Object.keys(overrides)) {
+          if (strict ? key === paramId : key.toLowerCase() === paramId.toLowerCase()) {
+            delete overrides[key];
+            deleted = true;
+          }
+        }
+      }
+    }
+    const rootParams = composition.composition.parameters;
+    if (rootParams) {
+      for (const paramId of parameterIds) {
+        for (const key of Object.keys(rootParams)) {
+          if (strict ? key === paramId : key.toLowerCase() === paramId.toLowerCase()) {
+            delete rootParams[key];
+            deleted = true;
+          }
+        }
+      }
+    }
+    return deleted;
+  }
+};
+
+// src/core/services/property-propagator.service.ts
+var PropertyPropagatorService = class {
+  constructor(fileSystem, componentService, compositionService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.compositionService = compositionService;
+    this.logger = logger;
+  }
+  async propagate(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionType,
+      property,
+      targetComponentType,
+      targetGroup,
+      whatIf,
+      strict,
+      deleteSourceParameter
+    } = options;
+    const findOptions = { strict };
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    this.logger.info(`Loading component: ${compositionType}`);
+    const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, compositionType, findOptions);
+    this.logger.info(`Loading component: ${targetComponentType}`);
+    const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
+    const propertyNames = property.split("|").map((p) => p.trim());
+    const { parameters: resolvedParams, notFound } = this.componentService.resolveProperties(
+      sourceComponent,
+      propertyNames,
+      findOptions
+    );
+    if (notFound.length > 0) {
+      throw new PropertyNotFoundError(notFound.join(", "), compositionType);
+    }
+    const resolvedNames = resolvedParams.map((p) => p.id);
+    const groupSources = propertyNames.filter((name) => {
+      const param = this.componentService.findParameter(sourceComponent, name, findOptions);
+      return param && this.componentService.isGroupParameter(param);
+    });
+    if (groupSources.length > 0) {
+      this.logger.info(
+        `Resolved properties: ${resolvedNames.join(", ")} (from ${groupSources.join(", ")})`
+      );
+    } else {
+      this.logger.info(`Resolved properties: ${resolvedNames.join(", ")}`);
+    }
+    let modifiedComponent = { ...targetComponent };
+    let componentModified = false;
+    const existingGroup = this.componentService.findParameter(
+      modifiedComponent,
+      targetGroup,
+      findOptions
+    );
+    if (!existingGroup) {
+      this.logger.action(whatIf, "CREATE", `Group "${targetGroup}" on ${targetComponentType}`);
+      modifiedComponent = this.componentService.ensureGroupExists(
+        modifiedComponent,
+        targetGroup,
+        void 0,
+        findOptions
+      );
+      componentModified = true;
+    }
+    for (const param of resolvedParams) {
+      const existingParam = this.componentService.findParameter(
+        modifiedComponent,
+        param.id,
+        findOptions
+      );
+      if (!existingParam) {
+        this.logger.action(
+          whatIf,
+          "COPY",
+          `Parameter "${param.id}" \u2192 ${targetComponentType}.${targetGroup}`
+        );
+        modifiedComponent = this.componentService.addParameterToComponent(
+          modifiedComponent,
+          param,
+          findOptions
+        );
+        modifiedComponent = this.componentService.addParameterToGroup(
+          modifiedComponent,
+          targetGroup,
+          param.id,
+          findOptions
+        );
+        componentModified = true;
+      } else {
+        this.logger.info(`Parameter "${param.id}" already exists on ${targetComponentType}`);
+        const group = this.componentService.findParameter(
+          modifiedComponent,
+          targetGroup,
+          findOptions
+        );
+        if (group && this.componentService.isGroupParameter(group)) {
+          const isInGroup = group.typeConfig?.childrenParams?.some(
+            (id) => strict ? id === param.id : id.toLowerCase() === param.id.toLowerCase()
+          );
+          if (!isInGroup) {
+            modifiedComponent = this.componentService.addParameterToGroup(
+              modifiedComponent,
+              targetGroup,
+              param.id,
+              findOptions
+            );
+            componentModified = true;
+          }
+        }
+      }
+    }
+    if (componentModified && !whatIf) {
+      await this.componentService.saveComponent(targetFilePath, modifiedComponent);
+    }
+    const compositions = await this.compositionService.findCompositionsByType(
+      fullCompositionsDir,
+      compositionType,
+      findOptions
+    );
+    let modifiedCompositions = 0;
+    let propagatedInstances = 0;
+    for (const { composition, filePath } of compositions) {
+      const rootOverrides = this.compositionService.getRootOverrides(composition);
+      const instances = this.compositionService.findComponentInstances(
+        composition,
+        targetComponentType,
+        findOptions
+      );
+      if (instances.length === 0) {
+        continue;
+      }
+      const valuesToPropagate = {};
+      for (const param of resolvedParams) {
+        if (rootOverrides[param.id]) {
+          valuesToPropagate[param.id] = rootOverrides[param.id];
+        }
+      }
+      if (Object.keys(valuesToPropagate).length === 0) {
+        continue;
+      }
+      let compositionModified = false;
+      const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+      const instanceUpdates = [];
+      for (const { instance, instanceId } of instances) {
+        const instanceName = instance._id ?? instanceId;
+        this.compositionService.setInstanceParameters(instance, valuesToPropagate);
+        compositionModified = true;
+        propagatedInstances++;
+        instanceUpdates.push(
+          `${targetComponentType} "${instanceName}": ${Object.keys(valuesToPropagate).join(", ")}`
+        );
+      }
+      if (compositionModified) {
+        this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
+        for (const update of instanceUpdates) {
+          this.logger.detail(`\u2192 ${update}`);
+        }
+        if (!whatIf) {
+          await this.compositionService.saveComposition(filePath, composition);
+        }
+        modifiedCompositions++;
+      }
+    }
+    let sourceComponentModified = false;
+    if (deleteSourceParameter) {
+      let modifiedSource = { ...sourceComponent };
+      for (const param of resolvedParams) {
+        this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${compositionType}`);
+        modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
+        sourceComponentModified = true;
+      }
+      const beforeGroupCount = modifiedSource.parameters?.filter(
+        (p) => this.componentService.isGroupParameter(p)
+      ).length ?? 0;
+      modifiedSource = this.componentService.removeEmptyGroups(modifiedSource);
+      const afterGroupCount = modifiedSource.parameters?.filter(
+        (p) => this.componentService.isGroupParameter(p)
+      ).length ?? 0;
+      if (afterGroupCount < beforeGroupCount) {
+        const removedCount = beforeGroupCount - afterGroupCount;
+        this.logger.action(
+          whatIf,
+          "DELETE",
+          `${removedCount} empty group(s) from ${compositionType}`
+        );
+      }
+      if (sourceComponentModified && !whatIf) {
+        await this.componentService.saveComponent(sourceFilePath, modifiedSource);
+      }
+      for (const { composition, filePath } of compositions) {
+        const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+        const deleted = this.compositionService.deleteRootOverrides(
+          composition,
+          resolvedNames,
+          findOptions
+        );
+        if (deleted) {
+          this.logger.action(whatIf, "DELETE", `Root overrides from composition/${relativePath}`);
+          this.logger.detail(`\u2192 Removed: ${resolvedNames.join(", ")}`);
+          if (!whatIf) {
+            await this.compositionService.saveComposition(filePath, composition);
+          }
+        }
+      }
+    }
+    return {
+      modifiedComponents: (componentModified ? 1 : 0) + (sourceComponentModified ? 1 : 0),
+      modifiedCompositions,
+      propagatedInstances
+    };
+  }
+};
+
+// src/cli/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  info(message) {
+    console.log(`${chalk.blue("[INFO]")} ${message}`);
+  }
+  success(message) {
+    console.log(`${chalk.green("[DONE]")} ${message}`);
+  }
+  error(message) {
+    console.log(`${chalk.red("[ERROR]")} ${message}`);
+  }
+  warn(message) {
+    console.log(`${chalk.yellow("[WARN]")} ${message}`);
+  }
+  action(whatIf, actionType, message) {
+    const prefix = whatIf ? chalk.yellow("[WOULD]") : chalk.green(`[${actionType}]`);
+    console.log(`${prefix} ${message}`);
+  }
+  detail(message) {
+    console.log(`  ${chalk.gray(message)}`);
+  }
+};
+
+// src/cli/commands/propagate-root-component-property.ts
+function createPropagateRootComponentPropertyCommand() {
+  const command = new Command("propagate-root-component-property");
+  command.description(
+    "Copies property definitions from a composition type's root component to a target component type, then propagates the actual values across all matching compositions."
+  ).option("--compositionType <type>", "The composition type to process (e.g., HomePage)").option("--property <properties>", "Pipe-separated list of properties and/or groups to copy").option(
+    "--targetComponentType <type>",
+    "The component type that will receive the copied properties"
+  ).option(
+    "--targetGroup <group>",
+    "The group name on the target component where properties will be placed"
+  ).option(
+    "--deleteSourceParameter",
+    "Delete the original parameters from the source component after propagation"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "compositionType", flag: "--compositionType" },
+      { name: "property", flag: "--property" },
+      { name: "targetComponentType", flag: "--targetComponentType" },
+      { name: "targetGroup", flag: "--targetGroup" }
+    ];
+    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,
+      compositionType: opts.compositionType,
+      property: opts.property,
+      targetComponentType: opts.targetComponentType,
+      targetGroup: opts.targetGroup,
+      deleteSourceParameter: opts.deleteSourceParameter
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const compositionService = new CompositionService(fileSystem);
+    const propagator = new PropertyPropagatorService(
+      fileSystem,
+      componentService,
+      compositionService,
+      logger
+    );
+    try {
+      const result = await propagator.propagate({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionType: options.compositionType,
+        property: options.property,
+        targetComponentType: options.targetComponentType,
+        targetGroup: options.targetGroup,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false,
+        deleteSourceParameter: options.deleteSourceParameter ?? false
+      });
+      logger.success(
+        `Modified ${result.modifiedComponents} component, ${result.modifiedCompositions} compositions`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/find-composition-pattern-candidates.ts
+import { Command as Command2 } from "commander";
+
+// src/core/services/pattern-analyzer.service.ts
+var PatternAnalyzerService = class {
+  constructor(fileSystem, compositionService, logger) {
+    this.fileSystem = fileSystem;
+    this.compositionService = compositionService;
+    this.logger = logger;
+  }
+  async analyze(options) {
+    const { rootDir, compositionsDir, projectMapNodesDir, minGroupSize, depth, threshold } = options;
+    const compositionsPath = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const projectMapNodesPath = this.fileSystem.resolvePath(rootDir, projectMapNodesDir);
+    const projectMapNodes = await this.loadProjectMapNodes(projectMapNodesPath);
+    const compositionFiles = await this.fileSystem.findFiles(
+      compositionsPath,
+      "**/*.{json,yaml,yml}"
+    );
+    this.logger.info(`Found ${compositionFiles.length} composition files`);
+    const loadedCompositions = [];
+    for (const filePath of compositionFiles) {
+      try {
+        const composition = await this.compositionService.loadComposition(filePath);
+        if (!composition.composition?.type) {
+          this.logger.warn(`Skipping ${filePath}: missing composition type`);
+          continue;
+        }
+        const fingerprint = this.generateFingerprint(composition, depth);
+        loadedCompositions.push({ composition, filePath, fingerprint });
+      } catch (error) {
+        this.logger.warn(
+          `Skipping ${filePath}: ${error instanceof Error ? error.message : "invalid file"}`
+        );
+      }
+    }
+    let groups;
+    if (threshold === 0) {
+      const fingerprintGroups = /* @__PURE__ */ new Map();
+      for (const item of loadedCompositions) {
+        if (!fingerprintGroups.has(item.fingerprint)) {
+          fingerprintGroups.set(item.fingerprint, []);
+        }
+        fingerprintGroups.get(item.fingerprint).push(item);
+      }
+      groups = Array.from(fingerprintGroups.values());
+    } else {
+      groups = this.clusterByThreshold(loadedCompositions, threshold, depth);
+    }
+    const allCompositions = loadedCompositions.map((item) => item.composition);
+    const allComponentTypes = this.extractComponentTypesFromCompositions(allCompositions);
+    const totalUniqueComponents = allComponentTypes.size;
+    const patterns = [];
+    const rootTypeCounts = /* @__PURE__ */ new Map();
+    const uniqueCompositionsList = [];
+    const uniqueCompositionsData = [];
+    const patternCompositionsData = /* @__PURE__ */ new Map();
+    for (const group of groups) {
+      if (group.length < minGroupSize) {
+        for (const { composition, filePath } of group) {
+          const info = {
+            id: composition.composition._id ?? "unknown",
+            name: this.getCompositionName(composition),
+            projectMapNodeSlug: this.resolveProjectMapSlug(composition, projectMapNodes),
+            filePath
+          };
+          uniqueCompositionsList.push(info);
+          uniqueCompositionsData.push({ info, composition });
+        }
+        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));
+    }
+    for (const pattern of patterns) {
+      const p = pattern;
+      if (rootTypeCounts.get(p._rootType) > 1) {
+        pattern.name = `${p._rootType}-${p._firstName}`;
+      }
+      delete pattern._rootType;
+      delete pattern._firstName;
+    }
+    patterns.sort((a, b) => b.compositions.length - a.compositions.length);
+    const seenComponents = this.computeComponentAnalysis(
+      patterns,
+      patternCompositionsData,
+      totalUniqueComponents
+    );
+    uniqueCompositionsList.sort((a, b) => a.id.localeCompare(b.id));
+    uniqueCompositionsData.sort((a, b) => a.info.id.localeCompare(b.info.id));
+    this.computeUniqueCompositionAnalysis(
+      uniqueCompositionsData,
+      seenComponents,
+      totalUniqueComponents
+    );
+    const totalCompositions = compositionFiles.length;
+    const uniquePatterns = patterns.length;
+    const compositionsInGroups = patterns.reduce((sum, p) => sum + p.compositions.length, 0);
+    const uniqueCompositionsCount = totalCompositions - compositionsInGroups;
+    return {
+      summary: {
+        totalCompositions,
+        uniquePatterns,
+        compositionsInGroups,
+        uniqueCompositions: uniqueCompositionsCount,
+        totalUniqueComponents
+      },
+      patterns,
+      uniqueCompositions: uniqueCompositionsList
+    };
+  }
+  /**
+   * Clusters compositions using Union-Find algorithm based on structural distance.
+   * Compositions with distance <= threshold are grouped together transitively.
+   */
+  clusterByThreshold(compositions, threshold, 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;
+        }
+        const distance = this.calculateDistance(parsedNodes[i], parsedNodes[j]);
+        if (distance <= threshold) {
+          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());
+  }
+  /**
+   * Parses a composition into a ComponentNode tree for structural comparison.
+   */
+  parseCompositionToNode(composition, depth) {
+    const root = composition.composition;
+    const remainingDepth = depth === 0 ? -1 : depth - 1;
+    return this.parseInstanceToNode(root.type, root.slots, remainingDepth);
+  }
+  parseInstanceToNode(type, slots, remainingDepth) {
+    const node = {
+      type,
+      slots: /* @__PURE__ */ new Map()
+    };
+    if (remainingDepth === 0 || !slots || Object.keys(slots).length === 0) {
+      return node;
+    }
+    const sortedSlotNames = Object.keys(slots).sort();
+    for (const slotName of sortedSlotNames) {
+      const instances = slots[slotName];
+      if (!Array.isArray(instances)) {
+        node.slots.set(slotName, []);
+        continue;
+      }
+      const nextDepth = remainingDepth === -1 ? -1 : remainingDepth - 1;
+      const childNodes = instances.map(
+        (instance) => this.parseInstanceToNode(instance.type, instance.slots, nextDepth)
+      );
+      node.slots.set(slotName, childNodes);
+    }
+    return node;
+  }
+  /**
+   * Calculates the structural distance between two ComponentNode trees.
+   * Distance is the number of component differences.
+   */
+  calculateDistance(node1, node2) {
+    let distance = 0;
+    if (node1.type !== node2.type) {
+      return Infinity;
+    }
+    const allSlotNames = /* @__PURE__ */ new Set([...node1.slots.keys(), ...node2.slots.keys()]);
+    for (const slotName of allSlotNames) {
+      const children1 = node1.slots.get(slotName) ?? [];
+      const children2 = node2.slots.get(slotName) ?? [];
+      const maxLen = Math.max(children1.length, children2.length);
+      for (let i = 0; i < maxLen; i++) {
+        const child1 = children1[i];
+        const child2 = children2[i];
+        if (!child1 || !child2) {
+          distance++;
+        } else if (child1.type !== child2.type) {
+          distance++;
+        } else {
+          distance += this.calculateDistance(child1, child2);
+        }
+      }
+    }
+    return distance;
+  }
+  /**
+   * Extracts all unique component types from a composition recursively.
+   */
+  extractComponentTypes(composition) {
+    const types = /* @__PURE__ */ new Set();
+    const root = composition.composition;
+    types.add(root.type);
+    this.collectComponentTypesFromSlots(root.slots, types);
+    return types;
+  }
+  /**
+   * Helper to recursively collect component types from slots.
+   */
+  collectComponentTypesFromSlots(slots, types) {
+    if (!slots) return;
+    for (const slotName of Object.keys(slots)) {
+      const instances = slots[slotName];
+      if (!Array.isArray(instances)) continue;
+      for (const instance of instances) {
+        types.add(instance.type);
+        this.collectComponentTypesFromSlots(instance.slots, types);
+      }
+    }
+  }
+  /**
+   * Extracts the union of all component types from multiple compositions.
+   */
+  extractComponentTypesFromCompositions(compositions) {
+    const types = /* @__PURE__ */ new Set();
+    for (const composition of compositions) {
+      const compositionTypes = this.extractComponentTypes(composition);
+      for (const type of compositionTypes) {
+        types.add(type);
+      }
+    }
+    return types;
+  }
+  /**
+   * Computes component analysis for all patterns.
+   * Returns the set of seen components for continuation with unique compositions.
+   */
+  computeComponentAnalysis(patterns, patternCompositionsData, totalUniqueComponents) {
+    const seenComponents = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      const compositions = patternCompositionsData.get(pattern) ?? [];
+      const patternComponents = this.extractComponentTypesFromCompositions(compositions);
+      const componentsUsed = Array.from(patternComponents).sort();
+      const reusedComponents = [];
+      const newComponents = [];
+      for (const component of componentsUsed) {
+        if (seenComponents.has(component)) {
+          reusedComponents.push(component);
+        } else {
+          newComponents.push(component);
+        }
+      }
+      for (const component of componentsUsed) {
+        seenComponents.add(component);
+      }
+      const cumulativeComponentCount = seenComponents.size;
+      const progressionPercentage = totalUniqueComponents > 0 ? Math.round(cumulativeComponentCount / totalUniqueComponents * 100) : 0;
+      pattern.componentAnalysis = {
+        componentsUsed,
+        reusedComponents: reusedComponents.sort(),
+        newComponents: newComponents.sort(),
+        cumulativeComponentCount,
+        progressionPercentage
+      };
+    }
+    return seenComponents;
+  }
+  /**
+   * Computes component analysis for unique compositions.
+   * Continues from the seenComponents set populated by pattern analysis.
+   */
+  computeUniqueCompositionAnalysis(uniqueCompositionsData, seenComponents, totalUniqueComponents) {
+    for (const { info, composition } of uniqueCompositionsData) {
+      const compositionComponents = this.extractComponentTypes(composition);
+      const componentsUsed = Array.from(compositionComponents).sort();
+      const reusedComponents = [];
+      const newComponents = [];
+      for (const component of componentsUsed) {
+        if (seenComponents.has(component)) {
+          reusedComponents.push(component);
+        } else {
+          newComponents.push(component);
+        }
+      }
+      for (const component of componentsUsed) {
+        seenComponents.add(component);
+      }
+      const cumulativeComponentCount = seenComponents.size;
+      const progressionPercentage = totalUniqueComponents > 0 ? Math.round(cumulativeComponentCount / totalUniqueComponents * 100) : 0;
+      info.componentAnalysis = {
+        componentsUsed,
+        reusedComponents: reusedComponents.sort(),
+        newComponents: newComponents.sort(),
+        cumulativeComponentCount,
+        progressionPercentage
+      };
+    }
+  }
+  /**
+   * Generates a structural fingerprint for a composition.
+   * The fingerprint captures the component type hierarchy ignoring parameter values.
+   * @param depth - How many levels deep to compare. 0 = unlimited, 1 = root only, 2 = root + children, etc.
+   */
+  generateFingerprint(composition, depth = 0) {
+    const root = composition.composition;
+    const remainingDepth = depth === 0 ? -1 : depth - 1;
+    return this.generateNodeFingerprint(root.type, root.slots, remainingDepth);
+  }
+  generateNodeFingerprint(type, slots, remainingDepth) {
+    if (remainingDepth === 0 || !slots || Object.keys(slots).length === 0) {
+      return type;
+    }
+    const sortedSlotNames = Object.keys(slots).sort();
+    const slotFingerprints = sortedSlotNames.map((slotName) => {
+      const instances = slots[slotName];
+      if (!Array.isArray(instances) || instances.length === 0) {
+        return `${slotName}:[]`;
+      }
+      const nextDepth = remainingDepth === -1 ? -1 : remainingDepth - 1;
+      const instanceFingerprints = instances.map(
+        (instance) => this.generateNodeFingerprint(instance.type, instance.slots, nextDepth)
+      );
+      return `${slotName}:[${instanceFingerprints.join(",")}]`;
+    });
+    return `${type}{${slotFingerprints.join(";")}}`;
+  }
+  /**
+   * Generates a human-readable structure description.
+   */
+  generateStructureDescription(composition) {
+    const root = composition.composition;
+    return this.generateNodeDescription(root.type, root.slots, 0);
+  }
+  generateNodeDescription(type, slots, depth) {
+    if (!slots || Object.keys(slots).length === 0) {
+      return type;
+    }
+    const sortedSlotNames = Object.keys(slots).sort();
+    const slotDescriptions = sortedSlotNames.map((slotName) => {
+      const instances = slots[slotName];
+      if (!Array.isArray(instances) || instances.length === 0) {
+        return null;
+      }
+      const instanceTypes = instances.map((instance) => {
+        if (instance.slots && Object.keys(instance.slots).length > 0) {
+          return this.generateNodeDescription(instance.type, instance.slots, depth + 1);
+        }
+        return instance.type;
+      });
+      return `${slotName}[${instanceTypes.join(", ")}]`;
+    }).filter(Boolean);
+    if (slotDescriptions.length === 0) {
+      return type;
+    }
+    return `${type} > ${slotDescriptions.join(" > ")}`;
+  }
+  getCompositionName(composition) {
+    const possibleNames = [
+      composition.name,
+      composition.composition._name,
+      composition.composition.name,
+      composition.composition._id
+    ];
+    for (const name of possibleNames) {
+      if (name && typeof name === "string") {
+        return name;
+      }
+    }
+    return "Unnamed";
+  }
+  async loadProjectMapNodes(projectMapNodesPath) {
+    const nodes = /* @__PURE__ */ new Map();
+    try {
+      const exists = await this.fileSystem.fileExists(projectMapNodesPath);
+      if (!exists) {
+        return nodes;
+      }
+      const files = await this.fileSystem.findFiles(projectMapNodesPath, "**/*.{json,yaml,yml}");
+      for (const filePath of files) {
+        try {
+          const node = await this.fileSystem.readFile(filePath);
+          if (node.compositionId) {
+            nodes.set(node.compositionId, node);
+          }
+          if (node.id) {
+            nodes.set(node.id, node);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return nodes;
+  }
+  resolveProjectMapSlug(composition, nodes) {
+    const compositionId = composition.composition._id;
+    if (!compositionId) {
+      return "(not mapped)";
+    }
+    const node = nodes.get(compositionId);
+    if (!node) {
+      return "(not mapped)";
+    }
+    return node.path ?? node.slug ?? "(not mapped)";
+  }
+  formatTextOutput(result, options) {
+    const brief = options?.brief ?? false;
+    const lines = [];
+    const padWidth = String(result.patterns.length).length.toString().length >= 3 ? String(result.patterns.length).length : 3;
+    lines.push("=== COMPOSITION PATTERN CANDIDATES ===");
+    lines.push("");
+    lines.push(`Total compositions analyzed: ${result.summary.totalCompositions}`);
+    lines.push(`Unique structural patterns found: ${result.summary.uniquePatterns}`);
+    const percentage = result.summary.totalCompositions > 0 ? Math.round(
+      result.summary.compositionsInGroups / result.summary.totalCompositions * 100
+    ) : 0;
+    lines.push(`Compositions in pattern groups: ${result.summary.compositionsInGroups} (${percentage}%)`);
+    lines.push(`Unique compositions (no matches): ${result.summary.uniqueCompositions}`);
+    lines.push(`Total unique components: ${result.summary.totalUniqueComponents}`);
+    lines.push("");
+    if (result.patterns.length === 0) {
+      lines.push("No pattern candidates found (all compositions have unique structures).");
+      return lines.join("\n");
+    }
+    lines.push("Pattern candidates index:");
+    result.patterns.forEach((pattern, index) => {
+      const patternNum = String(index + 1).padStart(padWidth, "0");
+      lines.push(`  ${patternNum}. ${pattern.name}`);
+      lines.push(`       (${pattern.compositions.length} compositions)`);
+    });
+    lines.push("");
+    lines.push("Pattern candidates:");
+    lines.push("");
+    result.patterns.forEach((pattern, index) => {
+      const patternNum = String(index + 1).padStart(padWidth, "0");
+      lines.push(`  Pattern ${patternNum}: ${pattern.name} (${pattern.compositions.length} compositions)`);
+      if (pattern.componentAnalysis) {
+        const ca = pattern.componentAnalysis;
+        const totalComponents = result.summary.totalUniqueComponents;
+        lines.push(`    Components used: ${ca.componentsUsed.length}/${totalComponents} (${ca.componentsUsed.join(", ")})`);
+        lines.push(`    Reused components: ${ca.reusedComponents.length}/${ca.componentsUsed.length}${ca.reusedComponents.length > 0 ? ` (${ca.reusedComponents.join(", ")})` : ""}`);
+        lines.push(`    New components: ${ca.newComponents.length}/${totalComponents} (${ca.newComponents.join(", ")})`);
+        lines.push(`    Components progression: ${ca.progressionPercentage}% (${ca.cumulativeComponentCount}/${totalComponents})`);
+      }
+      if (!brief) {
+        lines.push("    Structure:");
+        const treeLines = this.generateStructureTree(pattern.structureDescription);
+        treeLines.forEach((treeLine) => {
+          lines.push(`      ${treeLine}`);
+        });
+        lines.push("");
+        lines.push("    Compositions:");
+        pattern.compositions.forEach((comp, compIndex) => {
+          lines.push(`      ${compIndex + 1}. ID: ${comp.id}`);
+          lines.push(`         Name: ${comp.name}`);
+          lines.push(`         Node: ${comp.projectMapNodeSlug}`);
+          lines.push("");
+        });
+      }
+      lines.push("");
+    });
+    if (result.uniqueCompositions.length > 0) {
+      lines.push("");
+      lines.push("=== UNIQUE COMPOSITIONS (NO MATCHES) ===");
+      lines.push("");
+      result.uniqueCompositions.forEach((comp, index) => {
+        lines.push(`  ${index + 1}. ID: ${comp.id}`);
+        lines.push(`     Name: ${comp.name}`);
+        lines.push(`     Node: ${comp.projectMapNodeSlug}`);
+        if (comp.componentAnalysis) {
+          const ca = comp.componentAnalysis;
+          const totalComponents = result.summary.totalUniqueComponents;
+          lines.push(`     Components used: ${ca.componentsUsed.length}/${totalComponents} (${ca.componentsUsed.join(", ")})`);
+          lines.push(`     Reused components: ${ca.reusedComponents.length}/${ca.componentsUsed.length}${ca.reusedComponents.length > 0 ? ` (${ca.reusedComponents.join(", ")})` : ""}`);
+          lines.push(`     New components: ${ca.newComponents.length}/${totalComponents} (${ca.newComponents.join(", ")})`);
+          lines.push(`     Components progression: ${ca.progressionPercentage}% (${ca.cumulativeComponentCount}/${totalComponents})`);
+        }
+        lines.push("");
+      });
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generates a tree-style representation of the structure description.
+   */
+  generateStructureTree(structureDescription) {
+    const lines = [];
+    this.parseStructureToTree(structureDescription, 0, lines);
+    return lines;
+  }
+  parseStructureToTree(str, indent, lines) {
+    const indentStr = "  ".repeat(indent);
+    const arrowIndex = str.indexOf(" > ");
+    if (arrowIndex === -1) {
+      lines.push(`${indentStr}${str}`);
+      return;
+    }
+    const rootType = str.substring(0, arrowIndex);
+    lines.push(`${indentStr}${rootType}`);
+    const slotsStr = str.substring(arrowIndex + 3);
+    this.parseSlotsToTree(slotsStr, indent, lines);
+  }
+  parseSlotsToTree(str, indent, lines) {
+    const indentStr = "  ".repeat(indent);
+    const slots = this.splitTopLevelSlots(str);
+    for (const slot of slots) {
+      const bracketStart = slot.indexOf("[");
+      if (bracketStart === -1) {
+        lines.push(`${indentStr}${slot}`);
+        continue;
+      }
+      const slotName = slot.substring(0, bracketStart);
+      const bracketEnd = this.findMatchingBracket(slot, bracketStart);
+      const contents = slot.substring(bracketStart + 1, bracketEnd);
+      lines.push(`${indentStr}:${slotName}`);
+      const components = this.splitTopLevelComponents(contents);
+      for (const component of components) {
+        const compArrow = component.indexOf(" > ");
+        if (compArrow !== -1) {
+          this.parseStructureToTree(component, indent + 2, lines);
+        } else {
+          lines.push(`${indentStr}    ${component}`);
+        }
+      }
+    }
+  }
+  splitTopLevelSlots(str) {
+    const result = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+      if (char === "[") {
+        depth++;
+        current += char;
+      } else if (char === "]") {
+        depth--;
+        current += char;
+      } else if (char === " " && str.substring(i, i + 3) === " > " && depth === 0) {
+        if (current.trim()) {
+          result.push(current.trim());
+        }
+        current = "";
+        i += 2;
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      result.push(current.trim());
+    }
+    return result;
+  }
+  splitTopLevelComponents(str) {
+    const result = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+      if (char === "[" || char === "{") {
+        depth++;
+        current += char;
+      } else if (char === "]" || char === "}") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        if (current.trim()) {
+          result.push(current.trim());
+        }
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      result.push(current.trim());
+    }
+    return result;
+  }
+  findMatchingBracket(str, start) {
+    let depth = 0;
+    for (let i = start; i < str.length; i++) {
+      if (str[i] === "[") depth++;
+      else if (str[i] === "]") {
+        depth--;
+        if (depth === 0) return i;
+      }
+    }
+    return str.length;
+  }
+  formatJsonOutput(result) {
+    const cleanedPatterns = result.patterns.map(({ fingerprint, ...pattern }) => ({
+      ...pattern,
+      compositions: pattern.compositions.map(({ filePath, ...comp }) => comp)
+    }));
+    const cleanedUniqueCompositions = result.uniqueCompositions.map(({ filePath, ...comp }) => comp);
+    return JSON.stringify(
+      {
+        summary: result.summary,
+        patterns: cleanedPatterns,
+        uniqueCompositions: cleanedUniqueCompositions
+      },
+      null,
+      2
+    );
+  }
+};
+
+// src/cli/commands/find-composition-pattern-candidates.ts
+function createSilentLogger() {
+  return {
+    info: () => {
+    },
+    success: () => {
+    },
+    error: () => {
+    },
+    warn: () => {
+    },
+    action: () => {
+    },
+    detail: () => {
+    }
+  };
+}
+function createFindCompositionPatternCandidatesCommand() {
+  const command = new Command2("find-composition-pattern-candidates");
+  command.description(
+    "Analyzes all compositions to identify groups with identical structural patterns\u2014same component types arranged in the same slot hierarchy\u2014regardless of parameter values."
+  ).option(
+    "--minGroupSize <size>",
+    "Minimum number of compositions required to form a pattern candidate group",
+    "2"
+  ).option(
+    "--depth <levels>",
+    "How many levels deep to compare (0 = unlimited, 1 = root only, 2 = root + children)",
+    "0"
+  ).option(
+    "--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) => {
+    const opts = thisCommand.opts();
+    const minGroupSize = parseInt(opts.minGroupSize, 10);
+    if (isNaN(minGroupSize) || minGroupSize < 2) {
+      console.error("error: --minGroupSize must be a number >= 2");
+      process.exit(1);
+    }
+    const depth = parseInt(opts.depth, 10);
+    if (isNaN(depth) || depth < 0) {
+      console.error("error: --depth must be a number >= 0");
+      process.exit(1);
+    }
+    const threshold = parseInt(opts.threshold, 10);
+    if (isNaN(threshold) || threshold < 0) {
+      console.error("error: --threshold must be a number >= 0");
+      process.exit(1);
+    }
+    if (opts.format !== "text" && opts.format !== "json") {
+      console.error('error: --format must be "text" or "json"');
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      minGroupSize: parseInt(opts.minGroupSize, 10),
+      depth: parseInt(opts.depth, 10),
+      threshold: parseInt(opts.threshold, 10),
+      format: opts.format,
+      brief: opts.brief ?? false
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const compositionService = new CompositionService(fileSystem);
+    try {
+      const analysisLogger = options.format === "json" ? createSilentLogger() : logger;
+      const analyzer = new PatternAnalyzerService(fileSystem, compositionService, analysisLogger);
+      const result = await analyzer.analyze({
+        rootDir: options.rootDir,
+        compositionsDir: options.compositionsDir,
+        projectMapNodesDir: options.projectMapNodesDir,
+        minGroupSize: options.minGroupSize,
+        depth: options.depth,
+        threshold: options.threshold,
+        strict: options.strict ?? false
+      });
+      if (options.format === "json") {
+        console.log(analyzer.formatJsonOutput(result));
+      } else {
+        console.log(analyzer.formatTextOutput(result, { brief: options.brief }));
+      }
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/unpack-serialization.ts
+import { Command as Command3 } from "commander";
+
+// src/core/services/serialization-packer.service.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSplittableArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((item) => isPlainObject(item) && typeof item.id === "string");
+}
+function isStubArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (item) => isPlainObject(item) && typeof item.id === "string" && Object.keys(item).length === 1
+  );
+}
+var SerializationPackerService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async unpack(options) {
+    const inputFiles = await this.resolveInputFiles(options);
+    let skeletonFilesWritten = 0;
+    let fragmentFilesWritten = 0;
+    for (const filePath of inputFiles) {
+      const fileName = this.fileSystem.getBasename(filePath);
+      if (fileName.includes("!!")) {
+        continue;
+      }
+      this.logger.info(`Processing: ${fileName}`);
+      const data = await this.fileSystem.readFile(filePath);
+      const skeleton = structuredClone(data);
+      const fragments = [];
+      const dir = options.outputDir ? this.fileSystem.resolvePath(options.rootDir, options.outputDir) : this.fileSystem.getDirname(filePath);
+      this.walkForUnpack(skeleton, fileName, dir, filePath, fragments, options.format);
+      if (fragments.length === 0) {
+        this.logger.detail("No splittable arrays found, skipping");
+        continue;
+      }
+      const skeletonPath = options.outputDir ? this.fileSystem.joinPath(dir, fileName) : filePath;
+      this.logger.action(options.whatIf, "WRITE", `Skeleton: ${this.fileSystem.getBasename(skeletonPath)}`);
+      if (!options.whatIf) {
+        await this.fileSystem.writeFile(skeletonPath, skeleton);
+      }
+      skeletonFilesWritten++;
+      for (const fragment of fragments) {
+        this.logger.action(options.whatIf, "WRITE", `Fragment: ${this.fileSystem.getBasename(fragment.path)}`);
+        if (!options.whatIf) {
+          await this.fileSystem.writeFile(fragment.path, fragment.data);
+        }
+        fragmentFilesWritten++;
+      }
+    }
+    return {
+      processedFiles: inputFiles.filter((f) => !this.fileSystem.getBasename(f).includes("!!")).length,
+      skeletonFilesWritten,
+      fragmentFilesWritten
+    };
+  }
+  async pack(options) {
+    const inputFiles = await this.resolveInputFiles(options);
+    let packedFilesWritten = 0;
+    let fragmentsConsumed = 0;
+    let fragmentsDeleted = 0;
+    const consumedFragments = /* @__PURE__ */ new Set();
+    for (const filePath of inputFiles) {
+      const fileName = this.fileSystem.getBasename(filePath);
+      if (fileName.includes("!!")) {
+        continue;
+      }
+      this.logger.info(`Processing: ${fileName}`);
+      const data = await this.fileSystem.readFile(filePath);
+      if (!this.hasStubArrays(data)) {
+        this.logger.detail("No stub arrays found, skipping");
+        continue;
+      }
+      const dir = this.fileSystem.getDirname(filePath);
+      const consumed = await this.walkForPack(data, fileName, dir);
+      fragmentsConsumed += consumed.length;
+      for (const f of consumed) {
+        consumedFragments.add(f);
+      }
+      const outputPath = options.outputDir ? this.fileSystem.joinPath(
+        this.fileSystem.resolvePath(options.rootDir, options.outputDir),
+        fileName
+      ) : filePath;
+      this.logger.action(options.whatIf, "WRITE", `Packed: ${this.fileSystem.getBasename(outputPath)}`);
+      if (!options.whatIf) {
+        await this.fileSystem.writeFile(outputPath, data);
+      }
+      packedFilesWritten++;
+      if (!options.keepFragments) {
+        for (const fragmentPath of consumed) {
+          this.logger.action(options.whatIf, "DELETE", `Fragment: ${this.fileSystem.getBasename(fragmentPath)}`);
+          if (!options.whatIf) {
+            this.fileSystem.deleteFile(fragmentPath);
+          }
+          fragmentsDeleted++;
+        }
+      }
+    }
+    await this.warnOrphanedFragments(inputFiles, consumedFragments);
+    return {
+      processedFiles: inputFiles.filter((f) => !this.fileSystem.getBasename(f).includes("!!")).length,
+      packedFilesWritten,
+      fragmentsConsumed,
+      fragmentsDeleted
+    };
+  }
+  walkForUnpack(obj, chain, dir, sourceFilePath, fragments, format) {
+    if (!isPlainObject(obj)) {
+      return;
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      if (isSplittableArray(value)) {
+        const ids = value.map((item) => item.id);
+        const seen = /* @__PURE__ */ new Set();
+        for (const id of ids) {
+          if (seen.has(id)) {
+            throw new DuplicateIdError(id, key, sourceFilePath);
+          }
+          seen.add(id);
+        }
+        const stubs = [];
+        for (const item of value) {
+          const id = item.id;
+          stubs.push({ id });
+          const fragmentClone = structuredClone(item);
+          const ext = format === "json" ? ".json" : ".yaml";
+          const fragmentFileName = `${chain}!!${key}!!-id!!${id}${ext}`;
+          const fragmentPath = this.fileSystem.joinPath(dir, fragmentFileName);
+          this.walkForUnpack(fragmentClone, fragmentFileName, dir, sourceFilePath, fragments, format);
+          fragments.push({ path: fragmentPath, data: fragmentClone });
+        }
+        obj[key] = stubs;
+      } else if (isPlainObject(value)) {
+        this.walkForUnpack(value, chain, dir, sourceFilePath, fragments, format);
+      }
+    }
+  }
+  hasStubArrays(obj) {
+    if (!isPlainObject(obj)) {
+      return false;
+    }
+    for (const value of Object.values(obj)) {
+      if (isStubArray(value)) {
+        return true;
+      }
+      if (isPlainObject(value) && this.hasStubArrays(value)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async walkForPack(obj, chain, dir) {
+    if (!isPlainObject(obj)) {
+      return [];
+    }
+    const consumed = [];
+    for (const [key, value] of Object.entries(obj)) {
+      if (isStubArray(value)) {
+        const reassembled = [];
+        for (const stub of value) {
+          const id = stub.id;
+          let fragmentPath = this.fileSystem.joinPath(dir, `${chain}!!${key}!!-id!!${id}.yaml`);
+          let exists = await this.fileSystem.fileExists(fragmentPath);
+          if (!exists) {
+            fragmentPath = this.fileSystem.joinPath(dir, `${chain}!!${key}!!-id!!${id}.json`);
+            exists = await this.fileSystem.fileExists(fragmentPath);
+          }
+          if (!exists) {
+            throw new FileNotFoundError(fragmentPath);
+          }
+          const fragmentData = await this.fileSystem.readFile(fragmentPath);
+          consumed.push(fragmentPath);
+          const fragmentFileName = this.fileSystem.getBasename(fragmentPath);
+          const nestedConsumed = await this.walkForPack(fragmentData, fragmentFileName, dir);
+          consumed.push(...nestedConsumed);
+          reassembled.push(fragmentData);
+        }
+        obj[key] = reassembled;
+      } else if (isPlainObject(value)) {
+        const nestedConsumed = await this.walkForPack(value, chain, dir);
+        consumed.push(...nestedConsumed);
+      }
+    }
+    return consumed;
+  }
+  async warnOrphanedFragments(inputFiles, consumedFragments) {
+    const allFragments = inputFiles.filter((f) => this.fileSystem.getBasename(f).includes("!!"));
+    for (const fragmentPath of allFragments) {
+      if (!consumedFragments.has(fragmentPath)) {
+        this.logger.warn(`Orphaned fragment: ${this.fileSystem.getBasename(fragmentPath)}`);
+      }
+    }
+  }
+  async resolveInputFiles(options) {
+    if (options.file) {
+      const filePath = this.fileSystem.resolvePath(options.rootDir, options.file);
+      return [filePath];
+    }
+    if (options.sourceDir) {
+      const dir = this.fileSystem.resolvePath(options.rootDir, options.sourceDir);
+      const yamlFiles = await this.fileSystem.findFiles(dir, "*.yaml");
+      const jsonFiles = await this.fileSystem.findFiles(dir, "*.json");
+      return [...yamlFiles, ...jsonFiles].sort();
+    }
+    return [];
+  }
+};
+
+// src/cli/commands/unpack-serialization.ts
+function createUnpackSerializationCommand() {
+  const command = new Command3("unpack-serialization");
+  command.description(
+    "Splits serialization files into skeleton + fragment files keyed by id, enabling clean per-item git diffs."
+  ).option("--sourceDir <dir>", "Directory containing serialization files to unpack").option("--file <path>", "Single serialization file to unpack").option("--outputDir <dir>", "Output directory (defaults to same directory as source)").option("--format <format>", "Output format: yaml or json", "yaml").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (!opts.sourceDir && !opts.file) {
+      console.error("error: --sourceDir or --file is required");
+      process.exit(1);
+    }
+    if (opts.sourceDir && opts.file) {
+      console.error("error: --sourceDir and --file are mutually exclusive");
+      process.exit(1);
+    }
+    if (opts.format !== "yaml" && opts.format !== "json") {
+      console.error('error: --format must be "yaml" or "json"');
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      sourceDir: opts.sourceDir,
+      file: opts.file,
+      outputDir: opts.outputDir,
+      format: opts.format
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const packer = new SerializationPackerService(fileSystem, logger);
+    try {
+      const result = await packer.unpack({
+        sourceDir: options.sourceDir,
+        file: options.file,
+        outputDir: options.outputDir,
+        format: options.format,
+        whatIf: options.whatIf ?? false,
+        rootDir: options.rootDir
+      });
+      logger.success(
+        `Unpack complete: ${result.processedFiles} file(s) processed, ${result.skeletonFilesWritten} skeleton(s), ${result.fragmentFilesWritten} fragment(s)`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/pack-serialization.ts
+import { Command as Command4 } from "commander";
+function createPackSerializationCommand() {
+  const command = new Command4("pack-serialization");
+  command.description(
+    "Reassembles skeleton + fragment files back into complete serialization files."
+  ).option("--sourceDir <dir>", "Directory containing skeleton and fragment files to pack").option("--file <path>", "Single skeleton file to pack").option("--outputDir <dir>", "Output directory (defaults to same directory as source)").option("--keepFragments", "Keep fragment files after packing (default: delete them)").option("--format <format>", "Output format: yaml or json", "yaml").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (!opts.sourceDir && !opts.file) {
+      console.error("error: --sourceDir or --file is required");
+      process.exit(1);
+    }
+    if (opts.sourceDir && opts.file) {
+      console.error("error: --sourceDir and --file are mutually exclusive");
+      process.exit(1);
+    }
+    if (opts.format !== "yaml" && opts.format !== "json") {
+      console.error('error: --format must be "yaml" or "json"');
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      sourceDir: opts.sourceDir,
+      file: opts.file,
+      outputDir: opts.outputDir,
+      keepFragments: opts.keepFragments ?? false,
+      format: opts.format
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const packer = new SerializationPackerService(fileSystem, logger);
+    try {
+      const result = await packer.pack({
+        sourceDir: options.sourceDir,
+        file: options.file,
+        outputDir: options.outputDir,
+        keepFragments: options.keepFragments,
+        format: options.format,
+        whatIf: options.whatIf ?? false,
+        rootDir: options.rootDir
+      });
+      logger.success(
+        `Pack complete: ${result.processedFiles} file(s) processed, ${result.packedFilesWritten} packed, ${result.fragmentsConsumed} fragment(s) consumed, ${result.fragmentsDeleted} fragment(s) deleted`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/rename-slot.ts
+import { Command as Command5 } from "commander";
+
+// src/core/services/slot-renamer.service.ts
+var SlotRenamerService = class {
+  constructor(fileSystem, componentService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async rename(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      newSlotName,
+      whatIf,
+      strict
+    } = options;
+    const findOptions = { strict };
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
+    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
+    if (this.compareIds(slotId, newSlotId, strict)) {
+      throw new TransformError("New slot ID is the same as the current slot ID");
+    }
+    this.logger.info(`Loading component: ${componentType}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
+    if (!component.slots || component.slots.length === 0) {
+      throw new SlotNotFoundError(slotId, componentType);
+    }
+    const slotIndex = component.slots.findIndex(
+      (s) => this.compareIds(s.id, slotId, strict)
+    );
+    if (slotIndex === -1) {
+      throw new SlotNotFoundError(slotId, componentType);
+    }
+    const existingNewSlot = component.slots.find(
+      (s) => this.compareIds(s.id, newSlotId, strict)
+    );
+    if (existingNewSlot) {
+      throw new SlotAlreadyExistsError(newSlotId, componentType);
+    }
+    this.logger.action(
+      whatIf,
+      "UPDATE",
+      `Slot "${slotId}" \u2192 "${newSlotId}" in component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    component.slots[slotIndex].id = newSlotId;
+    if (newSlotName !== void 0) {
+      component.slots[slotIndex].name = newSlotName;
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, component);
+    }
+    const compositionsResult = await this.renameSlotInDirectory(
+      fullCompositionsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.renameSlotInDirectory(
+      fullCompositionPatternsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.renameSlotInDirectory(
+      fullComponentPatternsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    const totalFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
+    const totalInstances = compositionsResult.instancesRenamed + compositionPatternsResult.instancesRenamed + componentPatternsResult.instancesRenamed;
+    this.logger.info("");
+    this.logger.info(
+      `Summary: 1 component definition, ${totalFiles} file(s) (${totalInstances} instance(s)) updated.`
+    );
+    return {
+      componentDefinitionUpdated: true,
+      compositionsModified: compositionsResult.filesModified,
+      compositionPatternsModified: compositionPatternsResult.filesModified,
+      componentPatternsModified: componentPatternsResult.filesModified,
+      instancesRenamed: totalInstances
+    };
+  }
+  async renameSlotInDirectory(directory, componentType, oldSlotId, newSlotId, whatIf, strict, label) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    } catch {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    if (files.length === 0) {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    let filesModified = 0;
+    let instancesRenamed = 0;
+    for (const filePath of files) {
+      let composition;
+      try {
+        composition = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!composition?.composition) {
+        continue;
+      }
+      const count = this.renameSlotInTree(
+        composition.composition,
+        componentType,
+        oldSlotId,
+        newSlotId,
+        strict
+      );
+      if (count > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `${label}/${relativePath} (${count} instance(s) of ${componentType})`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
+        }
+        filesModified++;
+        instancesRenamed += count;
+      }
+    }
+    return { filesModified, instancesRenamed };
+  }
+  renameSlotInTree(node, componentType, oldSlotId, newSlotId, strict) {
+    let count = 0;
+    if (this.compareIds(node.type, componentType, strict) && node.slots) {
+      const result = this.renameSlotKey(node.slots, oldSlotId, newSlotId, strict);
+      if (result.renamed) {
+        node.slots = result.slots;
+        count++;
+      }
+    }
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.renameSlotInTree(instance, componentType, oldSlotId, newSlotId, strict);
+        }
+      }
+    }
+    return count;
+  }
+  renameSlotKey(slots, oldSlotId, newSlotId, strict) {
+    const matchingKey = Object.keys(slots).find(
+      (key) => this.compareIds(key, oldSlotId, strict)
+    );
+    if (!matchingKey) {
+      return { renamed: false, slots };
+    }
+    const newSlots = {};
+    for (const key of Object.keys(slots)) {
+      if (key === matchingKey) {
+        newSlots[newSlotId] = slots[key];
+      } else {
+        newSlots[key] = slots[key];
+      }
+    }
+    return { renamed: true, slots: newSlots };
+  }
+};
+
+// src/cli/commands/rename-slot.ts
+function createRenameSlotCommand() {
+  const command = new Command5("rename-slot");
+  command.description(
+    "Renames a slot in a component definition and updates all compositions, composition patterns, and component patterns that reference it."
+  ).option("--componentType <type>", "The component type that owns the slot being renamed").option("--slotId <id>", "The current slot ID to rename").option("--newSlotId <id>", "The new slot ID").option("--newSlotName <name>", "New display name for the slot (optional)").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "componentType", flag: "--componentType" },
+      { name: "slotId", flag: "--slotId" },
+      { name: "newSlotId", flag: "--newSlotId" }
+    ];
+    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,
+      componentType: opts.componentType,
+      slotId: opts.slotId,
+      newSlotId: opts.newSlotId,
+      newSlotName: opts.newSlotName
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const renamer = new SlotRenamerService(fileSystem, componentService, logger);
+    try {
+      const result = await renamer.rename({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        componentType: options.componentType,
+        slotId: options.slotId,
+        newSlotId: options.newSlotId,
+        newSlotName: options.newSlotName,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `Renamed slot: ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/rename-component.ts
+import { Command as Command6 } from "commander";
+
+// src/core/services/component-renamer.service.ts
+var ComponentRenamerService = class {
+  constructor(fileSystem, componentService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async rename(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      componentType,
+      newComponentType,
+      newComponentName,
+      whatIf,
+      strict
+    } = options;
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
+    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
+    const findOptions = { strict };
+    if (this.compareIds(componentType, newComponentType, strict)) {
+      throw new TransformError("New component type is the same as the current component type");
+    }
+    this.logger.info(`Loading component: ${componentType}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
+    let targetExists = false;
+    try {
+      await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
+      targetExists = true;
+    } catch (error) {
+      if (!(error instanceof ComponentNotFoundError)) {
+        throw error;
+      }
+    }
+    if (targetExists) {
+      throw new ComponentAlreadyExistsError(newComponentType, fullComponentsDir);
+    }
+    this.logger.action(
+      whatIf,
+      "UPDATE",
+      `Component ID "${componentType}" \u2192 "${newComponentType}" in component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    component.id = newComponentType;
+    if (newComponentName !== void 0) {
+      component.name = newComponentName;
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, component);
+    }
+    const ext = this.fileSystem.getExtension(componentFilePath);
+    const dir = this.fileSystem.getDirname(componentFilePath);
+    const newFilePath = this.fileSystem.joinPath(dir, `${newComponentType}${ext}`);
+    let fileRenamed = false;
+    if (componentFilePath !== newFilePath) {
+      this.logger.action(
+        whatIf,
+        "RENAME",
+        `component/${this.fileSystem.getBasename(componentFilePath)} \u2192 component/${this.fileSystem.getBasename(newFilePath)}`
+      );
+      if (!whatIf) {
+        await this.fileSystem.renameFile(componentFilePath, newFilePath);
+      }
+      fileRenamed = true;
+    }
+    const allowedComponentsUpdated = await this.updateAllowedComponents(
+      fullComponentsDir,
+      componentType,
+      newComponentType,
+      componentFilePath,
+      whatIf,
+      strict
+    );
+    const compositionsResult = await this.renameTypeInDirectory(
+      fullCompositionsDir,
+      componentType,
+      newComponentType,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.renameTypeInDirectory(
+      fullCompositionPatternsDir,
+      componentType,
+      newComponentType,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.renameTypeInDirectory(
+      fullComponentPatternsDir,
+      componentType,
+      newComponentType,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    const totalCompositionFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
+    const totalInstances = compositionsResult.instancesRenamed + compositionPatternsResult.instancesRenamed + componentPatternsResult.instancesRenamed;
+    this.logger.info("");
+    this.logger.info(
+      `Summary: 1 component renamed, ${allowedComponentsUpdated} component(s) with allowedComponents updated, ${totalCompositionFiles} composition file(s) (${totalInstances} instance(s)) updated.`
+    );
+    return {
+      componentRenamed: true,
+      fileRenamed,
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult.filesModified,
+      compositionPatternsModified: compositionPatternsResult.filesModified,
+      componentPatternsModified: componentPatternsResult.filesModified,
+      instancesRenamed: totalInstances
+    };
+  }
+  async updateAllowedComponents(componentsDir, oldType, newType, sourceFilePath, whatIf, strict) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(componentsDir, "*.{json,yaml,yml}");
+    } catch {
+      return 0;
+    }
+    let updatedCount = 0;
+    for (const filePath of files) {
+      if (filePath === sourceFilePath) continue;
+      let comp;
+      try {
+        comp = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!comp.slots || comp.slots.length === 0) continue;
+      let fileModified = false;
+      for (const slot of comp.slots) {
+        if (!slot.allowedComponents) continue;
+        for (let i = 0; i < slot.allowedComponents.length; i++) {
+          if (this.compareIds(slot.allowedComponents[i], oldType, strict)) {
+            slot.allowedComponents[i] = newType;
+            fileModified = true;
+          }
+        }
+      }
+      if (fileModified) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `allowedComponents in component/${this.fileSystem.getBasename(filePath)}: ${oldType} \u2192 ${newType}`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, comp);
+        }
+        updatedCount++;
+      }
+    }
+    return updatedCount;
+  }
+  async renameTypeInDirectory(directory, oldType, newType, whatIf, strict, label) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    } catch {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    if (files.length === 0) {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    let filesModified = 0;
+    let instancesRenamed = 0;
+    for (const filePath of files) {
+      let composition;
+      try {
+        composition = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!composition?.composition) continue;
+      const count = this.renameTypeInTree(composition.composition, oldType, newType, strict);
+      if (count > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `${label}/${relativePath} (${count} instance(s))`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
+        }
+        filesModified++;
+        instancesRenamed += count;
+      }
+    }
+    return { filesModified, instancesRenamed };
+  }
+  renameTypeInTree(node, oldType, newType, strict) {
+    let count = 0;
+    if (this.compareIds(node.type, oldType, strict)) {
+      node.type = newType;
+      count++;
+    }
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.renameTypeInTree(instance, oldType, newType, strict);
+        }
+      }
+    }
+    return count;
+  }
+};
+
+// src/cli/commands/rename-component.ts
+function createRenameComponentCommand() {
+  const command = new Command6("rename-component");
+  command.description(
+    "Renames a component type across definitions, filenames, allowedComponents, and all compositions."
+  ).option("--componentType <type>", "The current component type ID to rename").option("--newComponentType <type>", "The new component type ID").option("--newComponentName <name>", "New display name for the component (optional)").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "componentType", flag: "--componentType" },
+      { name: "newComponentType", flag: "--newComponentType" }
+    ];
+    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,
+      componentType: opts.componentType,
+      newComponentType: opts.newComponentType,
+      newComponentName: opts.newComponentName
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const renamer = new ComponentRenamerService(fileSystem, componentService, logger);
+    try {
+      const result = await renamer.rename({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        componentType: options.componentType,
+        newComponentType: options.newComponentType,
+        newComponentName: options.newComponentName,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `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 TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/index.ts
+var program = new Command7();
+program.name("uniform-transform").description("CLI tool for transforming Uniform.dev serialization files offline").version("1.0.0");
+program.requiredOption("--rootDir <path>", "Path to the serialization project root").option("--what-if", "Dry run mode - preview changes without modifying files", false).option("--strict", "Enable strict mode for case-sensitive matching", false).option("--compositionsDir <dir>", "Compositions directory name", "composition").option("--componentsDir <dir>", "Components directory name", "component").option("--contentTypesDir <dir>", "Content types directory name", "contentType").option("--assetsDir <dir>", "Assets directory name", "asset").option("--categoriesDir <dir>", "Categories directory name", "category").option("--componentPatternsDir <dir>", "Component patterns directory name", "componentPattern").option(
+  "--compositionPatternsDir <dir>",
+  "Composition patterns directory name",
+  "compositionPattern"
+).option("--dataTypesDir <dir>", "Data types directory name", "dataType").option("--entriesDir <dir>", "Entries directory name", "entry").option("--filesDir <dir>", "Files directory name", "files").option("--previewUrlsDir <dir>", "Preview URLs directory name", "previewUrl").option("--previewViewportsDir <dir>", "Preview viewports directory name", "previewViewport").option(
+  "--projectMapDefinitionsDir <dir>",
+  "Project map definitions directory name",
+  "projectMapDefinition"
+).option("--projectMapNodesDir <dir>", "Project map nodes directory name", "projectMapNode").option("--quirksDir <dir>", "Quirks directory name", "quirk");
+program.addCommand(createPropagateRootComponentPropertyCommand());
+program.addCommand(createFindCompositionPatternCandidatesCommand());
+program.addCommand(createUnpackSerializationCommand());
+program.addCommand(createPackSerializationCommand());
+program.addCommand(createRenameSlotCommand());
+program.addCommand(createRenameComponentCommand());
+program.parse();
+//# sourceMappingURL=index.js.map