@uniformdev/transformer 1.0.0 → 1.1.1

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -324,6 +324,34 @@ var ComponentService = class {
     });
     return component;
   }
+  // Slot methods
+  findSlot(component, slotId, options = {}) {
+    const { strict = false } = options;
+    return component.slots?.find((s) => this.compareIds(s.id, slotId, strict));
+  }
+  addSlot(component, slot) {
+    if (!component.slots) {
+      component.slots = [];
+    }
+    component.slots.push({ ...slot });
+    return component;
+  }
+  updateSlotAllowedComponents(component, slotId, allowedComponents, options = {}) {
+    const { strict = false } = options;
+    const slot = component.slots?.find((s) => this.compareIds(s.id, slotId, strict));
+    if (slot) {
+      slot.allowedComponents = allowedComponents;
+    }
+    return component;
+  }
+  removeSlot(component, slotId, options = {}) {
+    const { strict = false } = options;
+    if (!component.slots) {
+      return component;
+    }
+    component.slots = component.slots.filter((s) => !this.compareIds(s.id, slotId, strict));
+    return component;
+  }
 };
 
 // src/core/services/composition.service.ts
@@ -1417,11 +1445,11 @@ var PatternAnalyzerService = class {
     return str.length;
   }
   formatJsonOutput(result) {
-    const cleanedPatterns = result.patterns.map(({ fingerprint, ...pattern }) => ({
+    const cleanedPatterns = result.patterns.map(({ fingerprint: _fingerprint, ...pattern }) => ({
       ...pattern,
-      compositions: pattern.compositions.map(({ filePath, ...comp }) => comp)
+      compositions: pattern.compositions.map(({ filePath: _filePath, ...comp }) => comp)
     }));
-    const cleanedUniqueCompositions = result.uniqueCompositions.map(({ filePath, ...comp }) => comp);
+    const cleanedUniqueCompositions = result.uniqueCompositions.map(({ filePath: _filePath, ...comp }) => comp);
     return JSON.stringify(
       {
         summary: result.summary,
@@ -2377,8 +2405,830 @@ function createRenameComponentCommand() {
   return command;
 }
 
+// src/cli/commands/add-component.ts
+import { Command as Command7 } from "commander";
+
+// src/core/services/component-adder.service.ts
+import { randomUUID } from "crypto";
+var ComponentAdderService = 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();
+  }
+  parseParameters(parameterString) {
+    const result = {};
+    if (!parameterString) return result;
+    const pairs = parameterString.split("|");
+    for (const pair of pairs) {
+      const [key, ...valueParts] = pair.split(":");
+      if (key && valueParts.length > 0) {
+        result[key.trim()] = valueParts.join(":").trim();
+      }
+    }
+    return result;
+  }
+  generateId(baseName) {
+    return `${baseName}-${randomUUID().slice(0, 8)}`;
+  }
+  cloneComponentInstance(instance) {
+    const clone = JSON.parse(JSON.stringify(instance));
+    if (clone._id) {
+      clone._id = this.generateId(clone.type);
+    }
+    if (clone.slots) {
+      for (const slotInstances of Object.values(clone.slots)) {
+        if (Array.isArray(slotInstances)) {
+          for (const nestedInstance of slotInstances) {
+            this.regenerateInstanceIds(nestedInstance);
+          }
+        }
+      }
+    }
+    return clone;
+  }
+  regenerateInstanceIds(instance) {
+    if (instance._id) {
+      instance._id = this.generateId(instance.type);
+    }
+    if (instance.slots) {
+      for (const slotInstances of Object.values(instance.slots)) {
+        if (Array.isArray(slotInstances)) {
+          for (const nestedInstance of slotInstances) {
+            this.regenerateInstanceIds(nestedInstance);
+          }
+        }
+      }
+    }
+  }
+  createComponentInstance(componentType, parameters) {
+    const instance = {
+      type: componentType,
+      _id: this.generateId(componentType)
+    };
+    if (Object.keys(parameters).length > 0) {
+      instance.parameters = {};
+      for (const [key, value] of Object.entries(parameters)) {
+        instance.parameters[key] = {
+          type: "text",
+          value
+        };
+      }
+    }
+    return instance;
+  }
+  addComponentToSlot(slots, slotId, instance) {
+    if (!slots[slotId]) {
+      slots[slotId] = [];
+    }
+    slots[slotId].push(instance);
+  }
+  async addComponent(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      parentComponentType,
+      slot,
+      newComponentType,
+      parameters: paramString,
+      whatIf,
+      strict
+    } = options;
+    if (!newComponentType) {
+      throw new TransformError("newComponentType is required for add-component");
+    }
+    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 };
+    this.logger.info(`Loading parent component: ${parentComponentType}`);
+    const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions);
+    if (!parentComponent.slots) {
+      parentComponent.slots = [];
+    }
+    let slotDef = parentComponent.slots.find(
+      (s) => this.compareIds(s.id, slot, strict)
+    );
+    if (!slotDef) {
+      this.logger.info(`Slot "${slot}" not found on component "${parentComponentType}", creating it`);
+      slotDef = { id: slot, name: slot, allowedComponents: [] };
+      parentComponent.slots.push(slotDef);
+    }
+    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;
+    }
+    let allowedComponentsUpdated = false;
+    const slotIndex = parentComponent.slots?.findIndex(
+      (s) => this.compareIds(s.id, slotDef.id, strict)
+    );
+    if (slotIndex !== void 0 && slotIndex >= 0) {
+      const actualSlot = parentComponent.slots[slotIndex];
+      if (!actualSlot.allowedComponents) {
+        actualSlot.allowedComponents = [];
+      }
+      const isAlreadyAllowed = actualSlot.allowedComponents.some(
+        (c) => this.compareIds(c, newComponentType, strict)
+      );
+      if (!isAlreadyAllowed) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `Adding "${newComponentType}" to allowedComponents for slot "${slot}" on component "${parentComponentType}"`
+        );
+        actualSlot.allowedComponents.push(newComponentType);
+        if (!whatIf) {
+          await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
+        }
+        allowedComponentsUpdated = true;
+      }
+    }
+    const parsedParams = this.parseParameters(paramString);
+    const newInstance = this.createComponentInstance(newComponentType, parsedParams);
+    const compositionsResult = await this.addComponentToDirectory(
+      fullCompositionsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.addComponentToDirectory(
+      fullCompositionPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.addComponentToDirectory(
+      fullComponentPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    this.logger.info("");
+    this.logger.info(
+      `Summary: ${allowedComponentsUpdated ? "1 component definition updated, " : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+    );
+    return {
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult,
+      compositionPatternsModified: compositionPatternsResult,
+      componentPatternsModified: componentPatternsResult,
+      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
+    };
+  }
+  async addComponentPattern(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      parentComponentType,
+      slot,
+      componentPatternId,
+      whatIf,
+      strict
+    } = options;
+    if (!componentPatternId) {
+      throw new TransformError("componentPatternId is required for add-component-pattern");
+    }
+    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 };
+    this.logger.info(`Loading parent component: ${parentComponentType}`);
+    const { component: parentComponent } = await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions);
+    if (!parentComponent.slots) {
+      parentComponent.slots = [];
+    }
+    let slotDef = parentComponent.slots.find(
+      (s) => this.compareIds(s.id, slot, strict)
+    );
+    if (!slotDef) {
+      this.logger.info(`Slot "${slot}" not found on component "${parentComponentType}", creating it`);
+      slotDef = { id: slot, name: slot, allowedComponents: [] };
+      parentComponent.slots.push(slotDef);
+    }
+    this.logger.info(`Loading component pattern: ${componentPatternId}`);
+    const pattern = await this.loadComponentPattern(
+      fullComponentPatternsDir,
+      componentPatternId,
+      strict
+    );
+    const patternDefinition = pattern.definition;
+    if (!patternDefinition || !patternDefinition.type) {
+      throw new TransformError(
+        `Component pattern "${componentPatternId}" has no valid definition or missing type`
+      );
+    }
+    let allowedComponentsUpdated = false;
+    const componentTypeInPattern = patternDefinition.type;
+    const slotIndex = parentComponent.slots?.findIndex(
+      (s) => this.compareIds(s.id, slotDef.id, strict)
+    );
+    if (slotIndex !== void 0 && slotIndex >= 0) {
+      const actualSlot = parentComponent.slots[slotIndex];
+      if (!actualSlot.allowedComponents) {
+        actualSlot.allowedComponents = [];
+      }
+      const isAlreadyAllowed = actualSlot.allowedComponents.some(
+        (c) => this.compareIds(c, componentTypeInPattern, strict)
+      );
+      if (!isAlreadyAllowed) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `Adding "${componentTypeInPattern}" to allowedComponents for slot "${slot}" on component "${parentComponentType}"`
+        );
+        actualSlot.allowedComponents.push(componentTypeInPattern);
+        if (!whatIf) {
+          await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions).then(
+            ({ filePath }) => this.componentService.saveComponent(filePath, parentComponent)
+          );
+        }
+        allowedComponentsUpdated = true;
+      }
+    }
+    const newInstance = this.cloneComponentInstance(patternDefinition);
+    const compositionsResult = await this.addComponentToDirectory(
+      fullCompositionsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.addComponentToDirectory(
+      fullCompositionPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.addComponentToDirectory(
+      fullComponentPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    this.logger.info("");
+    this.logger.info(
+      `Summary: ${allowedComponentsUpdated ? "1 component definition updated, " : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+    );
+    return {
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult,
+      compositionPatternsModified: compositionPatternsResult,
+      componentPatternsModified: componentPatternsResult,
+      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
+    };
+  }
+  async loadComponentPattern(componentPatternsDir, patternId, strict) {
+    const jsonPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.json`);
+    const yamlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yaml`);
+    const ymlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yml`);
+    if (await this.fileSystem.fileExists(jsonPath)) {
+      return this.fileSystem.readFile(jsonPath);
+    }
+    if (await this.fileSystem.fileExists(yamlPath)) {
+      return this.fileSystem.readFile(yamlPath);
+    }
+    if (await this.fileSystem.fileExists(ymlPath)) {
+      return this.fileSystem.readFile(ymlPath);
+    }
+    if (!strict) {
+      const files = await this.fileSystem.findFiles(componentPatternsDir, "*.{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() === patternId.toLowerCase()) {
+          return this.fileSystem.readFile(filePath);
+        }
+      }
+    }
+    throw new TransformError(`Component pattern "${patternId}" not found in ${componentPatternsDir}`);
+  }
+  async addComponentToDirectory(directory, parentComponentType, slot, newInstance, whatIf, strict, dirType) {
+    const exists = await this.fileSystem.fileExists(directory);
+    if (!exists) {
+      this.logger.detail(`${dirType} directory does not exist, skipping`);
+      return 0;
+    }
+    const files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    let filesModified = 0;
+    for (const filePath of files) {
+      try {
+        const content = await this.fileSystem.readFile(filePath);
+        let composition = null;
+        let isComponentPattern = false;
+        if (dirType === "componentPattern" && content && typeof content === "object" && "definition" in content) {
+          isComponentPattern = true;
+          const pattern = content;
+          if (pattern.definition && pattern.definition.slots) {
+            composition = {
+              composition: {
+                _id: "pattern-root",
+                type: pattern.definition.type,
+                slots: pattern.definition.slots
+              }
+            };
+          }
+        } else {
+          composition = content;
+        }
+        if (!composition?.composition) {
+          continue;
+        }
+        const rootInstance = composition.composition;
+        let modified = false;
+        if (this.compareIds(rootInstance.type, parentComponentType, strict)) {
+          if (!rootInstance.slots) {
+            rootInstance.slots = {};
+          }
+          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
+          this.regenerateInstanceIds(instanceCopy);
+          this.addComponentToSlot(rootInstance.slots, slot, instanceCopy);
+          modified = true;
+        }
+        if (rootInstance.slots) {
+          const nestedModified = this.addComponentToNestedSlots(
+            rootInstance.slots,
+            parentComponentType,
+            slot,
+            newInstance,
+            strict
+          );
+          if (nestedModified) {
+            modified = true;
+          }
+        }
+        if (modified) {
+          this.logger.action(
+            whatIf,
+            "UPDATE",
+            `Adding "${newInstance.type}" to slot "${slot}" in ${dirType}/${this.fileSystem.getBasename(filePath)}`
+          );
+          if (!whatIf) {
+            if (isComponentPattern && content && typeof content === "object" && "definition" in content) {
+              const pattern = content;
+              if (rootInstance.slots) {
+                pattern.definition.slots = rootInstance.slots;
+              }
+            }
+            await this.fileSystem.writeFile(filePath, content);
+          }
+          filesModified++;
+        }
+      } catch (error) {
+        if (error instanceof Error && !error.message.includes("skipping")) {
+          this.logger.detail(`Skipping ${filePath}: ${error.message}`);
+        }
+      }
+    }
+    return filesModified;
+  }
+  addComponentToNestedSlots(slots, parentComponentType, slot, newInstance, strict) {
+    let modified = false;
+    for (const slotInstances of Object.values(slots)) {
+      if (!Array.isArray(slotInstances)) continue;
+      for (const instance of slotInstances) {
+        if (this.compareIds(instance.type, parentComponentType, strict)) {
+          if (!instance.slots) {
+            instance.slots = {};
+          }
+          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
+          this.regenerateInstanceIds(instanceCopy);
+          this.addComponentToSlot(instance.slots, slot, instanceCopy);
+          modified = true;
+        }
+        if (instance.slots) {
+          const nestedModified = this.addComponentToNestedSlots(
+            instance.slots,
+            parentComponentType,
+            slot,
+            newInstance,
+            strict
+          );
+          if (nestedModified) {
+            modified = true;
+          }
+        }
+      }
+    }
+    return modified;
+  }
+};
+
+// src/cli/commands/add-component.ts
+function createAddComponentCommand() {
+  const command = new Command7("add-component");
+  command.description("Adds a component instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component will be added").option("--newComponentType <type>", "The component type to add").option("--parameters <params>", "Pipe-separated parameter assignments (key1:value1|key2:value2)").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "parentComponentType", flag: "--parentComponentType" },
+      { name: "slot", flag: "--slot" },
+      { 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,
+      parentComponentType: opts.parentComponentType,
+      slot: opts.slot,
+      newComponentType: opts.newComponentType,
+      parameters: opts.parameters
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const adder = new ComponentAdderService(fileSystem, componentService, logger);
+    try {
+      const result = await adder.addComponent({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        parentComponentType: options.parentComponentType,
+        slot: options.slot,
+        newComponentType: options.newComponentType,
+        parameters: options.parameters,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `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 TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/add-component-pattern.ts
+import { Command as Command8 } from "commander";
+function createAddComponentPatternCommand() {
+  const command = new Command8("add-component-pattern");
+  command.description("Adds a component pattern instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component pattern will be added").option("--componentPatternId <id>", "The component pattern ID to add").option("--parameters <params>", "Pipe-separated parameter assignments (key1:value1|key2:value2)").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "parentComponentType", flag: "--parentComponentType" },
+      { name: "slot", flag: "--slot" },
+      { name: "componentPatternId", flag: "--componentPatternId" }
+    ];
+    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,
+      parentComponentType: opts.parentComponentType,
+      slot: opts.slot,
+      componentPatternId: opts.componentPatternId,
+      parameters: opts.parameters
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const adder = new ComponentAdderService(fileSystem, componentService, logger);
+    try {
+      const result = await adder.addComponentPattern({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        parentComponentType: options.parentComponentType,
+        slot: options.slot,
+        componentPatternId: options.componentPatternId,
+        parameters: options.parameters,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `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 TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/propagate-root-component-slot.ts
+import { Command as Command9 } from "commander";
+
+// src/core/services/slot-propagator.service.ts
+var SlotPropagatorService = 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,
+      slot,
+      targetComponentType,
+      targetSlot,
+      whatIf,
+      strict,
+      deleteSourceSlot
+    } = 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 slotNames = slot.split("|").map((s) => s.trim());
+    const resolvedSlots = [];
+    const notFound = [];
+    for (const slotName of slotNames) {
+      const slotDef = this.componentService.findSlot(sourceComponent, slotName, findOptions);
+      if (slotDef) {
+        resolvedSlots.push(slotDef);
+      } else {
+        notFound.push(slotName);
+      }
+    }
+    if (notFound.length > 0) {
+      throw new PropertyNotFoundError(`Slot "${notFound.join(", ")}"`, compositionType);
+    }
+    const resolvedSlotIds = resolvedSlots.map((s) => s.id);
+    this.logger.info(`Resolved slots: ${resolvedSlotIds.join(", ")}`);
+    let modifiedComponent = { ...targetComponent };
+    let componentModified = false;
+    const existingSlot = this.componentService.findSlot(modifiedComponent, targetSlot, findOptions);
+    if (!existingSlot) {
+      const mergedAllowedComponents = this.mergeAllowedComponents(resolvedSlots);
+      this.logger.action(whatIf, "CREATE", `Slot "${targetSlot}" on ${targetComponentType}`);
+      modifiedComponent = this.componentService.addSlot(modifiedComponent, {
+        id: targetSlot,
+        name: targetSlot,
+        allowedComponents: mergedAllowedComponents
+      });
+      componentModified = true;
+    } else {
+      const mergedAllowedComponents = this.mergeAllowedComponents([existingSlot, ...resolvedSlots]);
+      const existingAllowed = existingSlot.allowedComponents ?? [];
+      if (mergedAllowedComponents.length > existingAllowed.length) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `Slot "${targetSlot}" allowedComponents on ${targetComponentType}`
+        );
+        modifiedComponent = this.componentService.updateSlotAllowedComponents(
+          modifiedComponent,
+          targetSlot,
+          mergedAllowedComponents,
+          findOptions
+        );
+        componentModified = true;
+      } else {
+        this.logger.info(`Slot "${targetSlot}" already exists on ${targetComponentType}`);
+      }
+    }
+    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 rootSlots = composition.composition.slots ?? {};
+      const instances = this.compositionService.findComponentInstances(
+        composition,
+        targetComponentType,
+        findOptions
+      );
+      if (instances.length === 0) {
+        continue;
+      }
+      const componentsToPropagate = [];
+      for (const slotDef of resolvedSlots) {
+        const slotContent = rootSlots[slotDef.id] ?? [];
+        componentsToPropagate.push(...slotContent);
+      }
+      if (componentsToPropagate.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;
+        const clonedComponents = this.deepCloneComponents(componentsToPropagate);
+        this.addComponentsToInstanceSlot(instance, targetSlot, clonedComponents);
+        compositionModified = true;
+        propagatedInstances++;
+        instanceUpdates.push(
+          `${targetComponentType} "${instanceName}": ${componentsToPropagate.length} component(s) \u2192 ${targetSlot}`
+        );
+      }
+      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 (deleteSourceSlot) {
+      let modifiedSource = { ...sourceComponent };
+      for (const slotDef of resolvedSlots) {
+        this.logger.action(whatIf, "DELETE", `Slot "${slotDef.id}" from ${compositionType}`);
+        modifiedSource = this.componentService.removeSlot(modifiedSource, slotDef.id, findOptions);
+        sourceComponentModified = true;
+      }
+      if (sourceComponentModified && !whatIf) {
+        await this.componentService.saveComponent(sourceFilePath, modifiedSource);
+      }
+      for (const { composition, filePath } of compositions) {
+        const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+        let cleared = false;
+        for (const slotDef of resolvedSlots) {
+          if (composition.composition.slots?.[slotDef.id]?.length) {
+            composition.composition.slots[slotDef.id] = [];
+            cleared = true;
+          }
+        }
+        if (cleared) {
+          this.logger.action(whatIf, "CLEAR", `Root slots in composition/${relativePath}`);
+          this.logger.detail(`\u2192 Cleared: ${resolvedSlotIds.join(", ")}`);
+          if (!whatIf) {
+            await this.compositionService.saveComposition(filePath, composition);
+          }
+        }
+      }
+    }
+    return {
+      modifiedComponents: (componentModified ? 1 : 0) + (sourceComponentModified ? 1 : 0),
+      modifiedCompositions,
+      propagatedInstances
+    };
+  }
+  mergeAllowedComponents(slots) {
+    const allowed = /* @__PURE__ */ new Set();
+    for (const slot of slots) {
+      for (const comp of slot.allowedComponents ?? []) {
+        allowed.add(comp);
+      }
+    }
+    return Array.from(allowed).sort();
+  }
+  deepCloneComponents(components) {
+    return JSON.parse(JSON.stringify(components));
+  }
+  addComponentsToInstanceSlot(instance, slotName, components) {
+    if (!instance.slots) {
+      instance.slots = {};
+    }
+    if (!instance.slots[slotName]) {
+      instance.slots[slotName] = [];
+    }
+    instance.slots[slotName].push(...components);
+  }
+};
+
+// src/cli/commands/propagate-root-component-slot.ts
+function createPropagateRootComponentSlotCommand() {
+  const command = new Command9("propagate-root-component-slot");
+  command.description(
+    "Copies slot definitions from a composition type's root component to a target component type, then moves all component instances from that slot across all matching compositions."
+  ).option("--compositionType <type>", "The composition type to process (e.g., HomePage)").option("--slot <slots>", "Pipe-separated list of slot names to copy from the source component").option(
+    "--targetComponentType <type>",
+    "The component type that will receive the copied slots"
+  ).option(
+    "--targetSlot <slot>",
+    "The slot name on the target component where the contents will be placed"
+  ).option(
+    "--deleteSourceSlot",
+    "Delete the original slots from the source component after propagation"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "compositionType", flag: "--compositionType" },
+      { name: "slot", flag: "--slot" },
+      { name: "targetComponentType", flag: "--targetComponentType" },
+      { name: "targetSlot", flag: "--targetSlot" }
+    ];
+    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,
+      slot: opts.slot,
+      targetComponentType: opts.targetComponentType,
+      targetSlot: opts.targetSlot,
+      deleteSourceSlot: opts.deleteSourceSlot
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const compositionService = new CompositionService(fileSystem);
+    const propagator = new SlotPropagatorService(
+      fileSystem,
+      componentService,
+      compositionService,
+      logger
+    );
+    try {
+      const result = await propagator.propagate({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionType: options.compositionType,
+        slot: options.slot,
+        targetComponentType: options.targetComponentType,
+        targetSlot: options.targetSlot,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false,
+        deleteSourceSlot: options.deleteSourceSlot ?? false
+      });
+      logger.success(
+        `Modified ${result.modifiedComponents} component(s), ${result.modifiedCompositions} composition(s)`
+      );
+    } 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();
+var program = new Command10();
 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>",
@@ -2395,5 +3245,8 @@ program.addCommand(createUnpackSerializationCommand());
 program.addCommand(createPackSerializationCommand());
 program.addCommand(createRenameSlotCommand());
 program.addCommand(createRenameComponentCommand());
+program.addCommand(createAddComponentCommand());
+program.addCommand(createAddComponentPatternCommand());
+program.addCommand(createPropagateRootComponentSlotCommand());
 program.parse();
 //# sourceMappingURL=index.js.map