@salesforce/ui-bundle-template-cli 1.117.2

package/dist/commands/apply-patches.js

@@ -0,0 +1,804 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { execSync } from "child_process";
+import { randomBytes } from "crypto";
+import { cpSync, existsSync, rmSync, readdirSync, renameSync, mkdirSync, readFileSync, writeFileSync, } from "fs";
+import { tmpdir } from "os";
+import { join, relative, basename, dirname, isAbsolute } from "path";
+import { resolveDependencies } from "../core/dependency-resolver";
+import { applyFile, copySiteContainerTemplate, deleteFile, prependToFile, appendToFile, processUIBundleMetaFile, } from "../core/file-operations";
+import { mergePackageJson } from "../core/package-json-merger";
+import * as logger from "../utils/logger";
+import { getEffectivePathMappings, applyPathMappings } from "../utils/path-mappings";
+import { getMonorepoRoot, getSfdxProjectTemplatePath, getSiteContainerTemplatePath, getFeaturesDir, translatePathToBaseApp, translatePathToTargetApp, } from "../utils/paths";
+import { validateAndResolveFeaturePath, validateAndResolveAppPath, getUIBundlePath, } from "../utils/validation";
+/**
+ * Recursively discover all files in a directory
+ */
+function discoverFiles(dir, baseDir = dir) {
+    const files = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...discoverFiles(fullPath, baseDir));
+        }
+        else if (entry.isFile()) {
+            // Get relative path from baseDir
+            files.push(relative(baseDir, fullPath));
+        }
+    }
+    return files;
+}
+const UIBUNDLE_META_PATTERN = /^_uibundle\.uibundle-meta\.xml$/i;
+/**
+ * Rewrite workspace package dependencies in the dist app's package.json to use
+ * local file: paths so `npm install` resolves them without the npm registry.
+ * Only rewrites packages that exist as local workspace directories.
+ */
+function rewriteWorkspaceDepsToLocalPaths(targetAppDir, monorepoRoot) {
+    const pkgJsonPath = join(targetAppDir, "package.json");
+    if (!existsSync(pkgJsonPath))
+        return;
+    const localPackageMap = {
+        "@salesforce/ui-bundle": join(monorepoRoot, "packages", "ui-bundle"),
+        "@salesforce/vite-plugin-ui-bundle": join(monorepoRoot, "packages", "vite-plugin-ui-bundle"),
+        "@salesforce/sdk-core": join(monorepoRoot, "packages", "sdk", "sdk-core"),
+        "@salesforce/sdk-data": join(monorepoRoot, "packages", "sdk", "sdk-data"),
+        "@salesforce/sdk-chat": join(monorepoRoot, "packages", "sdk", "sdk-chat"),
+        "@salesforce/sdk-view": join(monorepoRoot, "packages", "sdk", "sdk-view"),
+        "@salesforce/sdk-lightning": join(monorepoRoot, "packages", "sdk", "sdk-lightning"),
+    };
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    let changed = false;
+    for (const depType of ["dependencies", "devDependencies"]) {
+        const deps = pkgJson[depType];
+        if (!deps)
+            continue;
+        for (const [name, version] of Object.entries(deps)) {
+            if (typeof version === "string" && !version.startsWith("file:") && localPackageMap[name]) {
+                const localPath = localPackageMap[name];
+                if (existsSync(localPath)) {
+                    deps[name] = `file:${relative(targetAppDir, localPath)}`;
+                    changed = true;
+                }
+            }
+        }
+    }
+    if (changed) {
+        writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf-8");
+        logger.info("Rewrote workspace dependencies to local file: paths");
+    }
+}
+/**
+ * Process the UI bundle meta file in the target app dir after a base copy:
+ * replace <%= masterLabel %> with app name and rename _uibundle.*-meta.xml to <appName>.uibundle-meta.xml.
+ */
+function processUIBundleMetaInDir(targetAppDir, appName) {
+    if (!existsSync(targetAppDir))
+        return;
+    const entries = readdirSync(targetAppDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isFile() && UIBUNDLE_META_PATTERN.test(entry.name)) {
+            processUIBundleMetaFile(join(targetAppDir, entry.name), appName);
+            return;
+        }
+    }
+}
+/**
+ * Reset target directory to match base app state (excluding node_modules).
+ * This syncs the target directory with the base app before applying features.
+ */
+function resetTargetToBaseApp(targetDir, baseAppPath, targetAppName) {
+    const targetAppDir = join(targetDir, "force-app", "main", "default", "uiBundles", targetAppName);
+    const sourceUIBundlePath = getUIBundlePath(baseAppPath);
+    // Helper to check if path contains node_modules
+    const isNodeModulesPath = (path) => {
+        return path.split("/").includes("node_modules");
+    };
+    // Step 1: Remove files/directories from target that don't exist in base app
+    const removeExtraFiles = (targetPath, sourcePath) => {
+        if (!existsSync(targetPath))
+            return;
+        const entries = readdirSync(targetPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const targetEntryPath = join(targetPath, entry.name);
+            const sourceEntryPath = join(sourcePath, entry.name);
+            const relativeFromTarget = relative(targetAppDir, targetEntryPath);
+            // Skip node_modules
+            if (isNodeModulesPath(relativeFromTarget)) {
+                continue;
+            }
+            if (!existsSync(sourceEntryPath)) {
+                // Doesn't exist in base app, remove it
+                rmSync(targetEntryPath, { recursive: true, force: true });
+                const suffix = entry.isDirectory() ? "/" : "";
+                logger.info(`Removed: ${relativeFromTarget}${suffix}`);
+            }
+            else if (entry.isDirectory()) {
+                // Recurse into directory
+                removeExtraFiles(targetEntryPath, sourceEntryPath);
+            }
+        }
+    };
+    // Step 2: Copy/update files from base app to target
+    const syncFiles = (sourcePath, targetPath) => {
+        if (!existsSync(sourcePath))
+            return;
+        const entries = readdirSync(sourcePath, { withFileTypes: true });
+        for (const entry of entries) {
+            const sourceEntryPath = join(sourcePath, entry.name);
+            const targetEntryPath = join(targetPath, entry.name);
+            const relativeFromTarget = relative(targetAppDir, targetEntryPath);
+            // Skip node_modules
+            if (isNodeModulesPath(relativeFromTarget)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                // Ensure directory exists in target
+                if (!existsSync(targetEntryPath)) {
+                    mkdirSync(targetEntryPath, { recursive: true });
+                }
+                // Recurse into directory
+                syncFiles(sourceEntryPath, targetEntryPath);
+            }
+            else if (entry.isFile()) {
+                // Copy file if it doesn't exist or is different
+                let shouldCopy = false;
+                if (!existsSync(targetEntryPath)) {
+                    shouldCopy = true;
+                }
+                else {
+                    // Compare file contents
+                    const sourceContent = readFileSync(sourceEntryPath);
+                    const targetContent = readFileSync(targetEntryPath);
+                    shouldCopy = !sourceContent.equals(targetContent);
+                }
+                if (shouldCopy) {
+                    cpSync(sourceEntryPath, targetEntryPath);
+                    logger.info(`Synced: ${relativeFromTarget}`);
+                }
+            }
+        }
+    };
+    logger.info("Resetting target directory to base app state...");
+    removeExtraFiles(targetAppDir, sourceUIBundlePath);
+    syncFiles(sourceUIBundlePath, targetAppDir);
+    processUIBundleMetaInDir(targetAppDir, targetAppName);
+    logger.success("Target directory reset complete");
+}
+const DELETE_PREFIX = "__delete__";
+const INHERIT_PREFIX = "__inherit__";
+const PREPEND_PREFIX = "__prepend__";
+const APPEND_PREFIX = "__append__";
+/**
+ * Check if a path component has the delete prefix and return the actual path
+ * Returns null if no delete prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/__delete__routes.tsx" -> "src/routes.tsx"
+ * - "src/__delete__pages" -> "src/pages"
+ * - "__delete__src/routes.tsx" -> "src/routes.tsx"
+ * - "src/routes.tsx" -> null (no prefix)
+ */
+function extractDeletePath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasDeletePrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(DELETE_PREFIX)) {
+            hasDeletePrefix = true;
+            return part.substring(DELETE_PREFIX.length);
+        }
+        return part;
+    });
+    return hasDeletePrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Check if a path component has the inherit prefix and return the actual path
+ * Returns null if no inherit prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/__inherit__routes.tsx" -> "src/routes.tsx"
+ * - "__inherit__src/routes.tsx" -> "src/routes.tsx"
+ * - "src/routes.tsx" -> null (no prefix)
+ */
+function extractInheritPath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasInheritPrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(INHERIT_PREFIX)) {
+            hasInheritPrefix = true;
+            return part.substring(INHERIT_PREFIX.length);
+        }
+        return part;
+    });
+    return hasInheritPrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Check if a path component has the prepend prefix and return the actual path
+ * Returns null if no prepend prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/styles/__prepend__global.css" -> "src/styles/global.css"
+ * - "__prepend__file.txt" -> "file.txt"
+ * - "src/file.tsx" -> null (no prefix)
+ */
+function extractPrependPath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasPrependPrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(PREPEND_PREFIX)) {
+            hasPrependPrefix = true;
+            return part.substring(PREPEND_PREFIX.length);
+        }
+        return part;
+    });
+    return hasPrependPrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Check if a path component has the append prefix and return the actual path
+ * Returns null if no append prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/styles/__append__global.css" -> "src/styles/global.css"
+ * - "__append__file.txt" -> "file.txt"
+ * - "src/file.tsx" -> null (no prefix)
+ */
+function extractAppendPath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasAppendPrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(APPEND_PREFIX)) {
+            hasAppendPrefix = true;
+            return part.substring(APPEND_PREFIX.length);
+        }
+        return part;
+    });
+    return hasAppendPrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Apply a single patch's files to the target directory
+ * This is the core application logic extracted for reuse
+ */
+async function applySinglePatch(resolvedPatch, baseAppPath, targetDir, targetAppName) {
+    const { patchDir, config, patchPath } = resolvedPatch;
+    const { templateDir, routeFilePath, pathMappings } = config;
+    // Extract feature name for path translation
+    const featureName = basename(patchPath);
+    // Get effective path mappings for this feature
+    const effectiveMappings = getEffectivePathMappings(featureName, pathMappings);
+    // Discover and apply files from feature's template directory
+    const templatePath = join(patchDir, templateDir);
+    if (!existsSync(templatePath)) {
+        throw new Error(`Template directory '${templateDir}' does not exist in feature path '${patchPath}'`);
+    }
+    logger.heading(`\nApplying: ${patchPath}`);
+    logger.info("Discovering files...");
+    const discoveredFiles = discoverFiles(templatePath);
+    if (discoveredFiles.length === 0) {
+        throw new Error(`Feature '${patchPath}' has no files in ${templateDir} directory`);
+    }
+    logger.info(`Found ${discoveredFiles.length} file(s)`);
+    // Validate that there are no conflicting paths and that base files exist
+    logger.info("Validating paths...");
+    const normalizedPaths = new Map();
+    const deleteFiles = [];
+    const inheritFiles = [];
+    const prependFiles = [];
+    const appendFiles = [];
+    for (const relativePath of discoveredFiles) {
+        // Apply path mappings to transform template path
+        const mappedPath = applyPathMappings(relativePath, effectiveMappings);
+        const deleteTargetPath = extractDeletePath(mappedPath);
+        const inheritTargetPath = extractInheritPath(mappedPath);
+        const prependTargetPath = extractPrependPath(mappedPath);
+        const appendTargetPath = extractAppendPath(mappedPath);
+        let normalizedPath;
+        let type;
+        if (deleteTargetPath) {
+            normalizedPath = deleteTargetPath;
+            type = "delete";
+            deleteFiles.push(deleteTargetPath);
+        }
+        else if (inheritTargetPath) {
+            normalizedPath = inheritTargetPath;
+            type = "inherit";
+            inheritFiles.push(inheritTargetPath);
+        }
+        else if (prependTargetPath) {
+            normalizedPath = prependTargetPath;
+            type = "prepend";
+            prependFiles.push(prependTargetPath);
+        }
+        else if (appendTargetPath) {
+            normalizedPath = appendTargetPath;
+            type = "append";
+            appendFiles.push(appendTargetPath);
+        }
+        else {
+            normalizedPath = mappedPath;
+            type = "normal";
+        }
+        // Check for conflicts
+        if (normalizedPaths.has(normalizedPath)) {
+            const existing = normalizedPaths.get(normalizedPath);
+            logger.error("\nPath conflict detected!\n");
+            logger.info(`The following paths resolve to the same target file:`);
+            logger.info(`  1. ${existing.path} (${existing.type})`);
+            logger.info(`  2. ${relativePath} (${type})`);
+            logger.info(`  → Both target: ${normalizedPath}\n`);
+            logger.warning("You cannot have multiple files targeting the same path.");
+            logger.info("Please remove one of these files from the template directory.\n");
+            throw new Error("Path conflict - cannot proceed");
+        }
+        normalizedPaths.set(normalizedPath, { path: relativePath, type });
+    }
+    // Validate that files marked for deletion exist
+    // Note: Files may exist in target (from dependencies) or will be inherited from base app
+    for (const deleteFile of deleteFiles) {
+        // Translate feature path to target app path
+        const targetPath = translatePathToTargetApp(deleteFile, featureName, targetAppName);
+        const targetFilePath = join(targetDir, targetPath);
+        // If file doesn't exist in target yet, check if it will be copied from base app during deletion
+        if (!existsSync(targetFilePath)) {
+            // Check if file exists in base app (will be inherited during delete operation)
+            const translatedPath = translatePathToBaseApp(deleteFile, featureName, baseAppPath);
+            const baseFilePath = join(baseAppPath, translatedPath);
+            if (!existsSync(baseFilePath)) {
+                logger.error(`\nValidation error: Cannot delete file that doesn't exist!\n`);
+                logger.info(`File marked for deletion: ${deleteFile}`);
+                logger.info(`Not found in target: ${targetFilePath}`);
+                logger.info(`Not found in base app: ${baseFilePath}`);
+                logger.warning(`The file must exist in target or base app to be deleted.\n`);
+                throw new Error("Delete validation failed - cannot proceed");
+            }
+        }
+    }
+    // Validate that files marked for inheritance exist in base app
+    for (const inheritFile of inheritFiles) {
+        // Translate feature path to target app path
+        const targetPath = translatePathToTargetApp(inheritFile, featureName, targetAppName);
+        const targetFilePath = join(targetDir, targetPath);
+        // If file doesn't exist in target yet, check if it will be copied from base app during inheritance
+        if (!existsSync(targetFilePath)) {
+            // Translate feature path to base app path (we inherit from base app)
+            const translatedPath = translatePathToBaseApp(inheritFile, featureName, baseAppPath);
+            const baseFilePath = join(baseAppPath, translatedPath);
+            if (!existsSync(baseFilePath)) {
+                logger.error(`\nValidation error: Cannot inherit file that doesn't exist!\n`);
+                logger.info(`File marked for inheritance: ${inheritFile}`);
+                logger.info(`Translated to: ${translatedPath}`);
+                logger.info(`Expected location in base app: ${baseFilePath}`);
+                logger.warning(`The file doesn't exist in the base app.\n`);
+                throw new Error("Inherit validation failed - cannot proceed");
+            }
+        }
+    }
+    // Validate that files marked for prepending exist in base app
+    for (const prependFile of prependFiles) {
+        // Translate feature path to base app path (we prepend to base app files)
+        const translatedPath = translatePathToBaseApp(prependFile, featureName, baseAppPath);
+        const baseFilePath = join(baseAppPath, translatedPath);
+        if (!existsSync(baseFilePath)) {
+            logger.error(`\nValidation error: Cannot prepend to file that doesn't exist!\n`);
+            logger.info(`File marked for prepending: ${prependFile}`);
+            logger.info(`Translated to: ${translatedPath}`);
+            logger.info(`Expected location in base app: ${baseFilePath}`);
+            logger.warning(`The file doesn't exist in the base app.\n`);
+            throw new Error("Prepend validation failed - cannot proceed");
+        }
+    }
+    // Validate that files marked for appending exist in base app
+    for (const appendFile of appendFiles) {
+        // Translate feature path to base app path (we append to base app files)
+        const translatedPath = translatePathToBaseApp(appendFile, featureName, baseAppPath);
+        const baseFilePath = join(baseAppPath, translatedPath);
+        if (!existsSync(baseFilePath)) {
+            logger.error(`\nValidation error: Cannot append to file that doesn't exist!\n`);
+            logger.info(`File marked for appending: ${appendFile}`);
+            logger.info(`Translated to: ${translatedPath}`);
+            logger.info(`Expected location in base app: ${baseFilePath}`);
+            logger.warning(`The file doesn't exist in the base app.\n`);
+            throw new Error("Append validation failed - cannot proceed");
+        }
+    }
+    logger.success("Paths validated");
+    // Apply each discovered file
+    for (const relativePath of discoveredFiles) {
+        // Apply path mappings to transform template path
+        const mappedPath = applyPathMappings(relativePath, effectiveMappings);
+        // Translate feature path to base app path (for finding base files)
+        const translatedPath = translatePathToBaseApp(mappedPath, featureName, baseAppPath);
+        // Translate feature path to target app path (for writing files)
+        const targetPath = translatePathToTargetApp(mappedPath, featureName, targetAppName);
+        // Check if this is a special operation
+        const deleteTargetPath = extractDeletePath(mappedPath);
+        const inheritTargetPath = extractInheritPath(mappedPath);
+        const prependTargetPath = extractPrependPath(mappedPath);
+        const appendTargetPath = extractAppendPath(mappedPath);
+        if (deleteTargetPath) {
+            // This is a delete operation - delete the target file/directory
+            const targetDeletePath = translatePathToTargetApp(deleteTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetDeletePath);
+            await deleteFile(targetFilePath, targetDeletePath);
+        }
+        else if (inheritTargetPath) {
+            // This is an inherit operation - copy from base app if target doesn't have it
+            const targetInheritPath = translatePathToTargetApp(inheritTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetInheritPath);
+            if (!existsSync(targetFilePath)) {
+                // Copy from base app to preserve inherited file in new target structure
+                const translatedInheritPath = translatePathToBaseApp(inheritTargetPath, featureName, baseAppPath);
+                const baseFilePath = join(baseAppPath, translatedInheritPath);
+                if (existsSync(baseFilePath)) {
+                    const targetFileDir = dirname(targetFilePath);
+                    if (!existsSync(targetFileDir)) {
+                        mkdirSync(targetFileDir, { recursive: true });
+                    }
+                    cpSync(baseFilePath, targetFilePath);
+                    logger.info(`Copied ${targetInheritPath} (inherited from base app)`);
+                }
+                else {
+                    logger.info(`Skipped ${targetInheritPath} (file not in base app)`);
+                }
+            }
+            else {
+                logger.info(`Skipped ${targetInheritPath} (already exists in target)`);
+            }
+        }
+        else if (prependTargetPath) {
+            // This is a prepend operation - ensure target file exists first
+            const patchSourceFilePath = join(templatePath, relativePath);
+            const targetPrependPath = translatePathToTargetApp(prependTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetPrependPath);
+            // Copy from base app if target doesn't have the file yet
+            if (!existsSync(targetFilePath)) {
+                const translatedPrependPath = translatePathToBaseApp(prependTargetPath, featureName, baseAppPath);
+                const baseFilePath = join(baseAppPath, translatedPrependPath);
+                if (existsSync(baseFilePath)) {
+                    const targetFileDir = dirname(targetFilePath);
+                    if (!existsSync(targetFileDir)) {
+                        mkdirSync(targetFileDir, { recursive: true });
+                    }
+                    cpSync(baseFilePath, targetFilePath);
+                }
+            }
+            await prependToFile(patchSourceFilePath, targetFilePath, targetPrependPath);
+        }
+        else if (appendTargetPath) {
+            // This is an append operation - ensure target file exists first
+            const patchSourceFilePath = join(templatePath, relativePath);
+            const targetAppendPath = translatePathToTargetApp(appendTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetAppendPath);
+            // Copy from base app if target doesn't have the file yet
+            if (!existsSync(targetFilePath)) {
+                const translatedAppendPath = translatePathToBaseApp(appendTargetPath, featureName, baseAppPath);
+                const baseFilePath = join(baseAppPath, translatedAppendPath);
+                if (existsSync(baseFilePath)) {
+                    const targetFileDir = dirname(targetFilePath);
+                    if (!existsSync(targetFileDir)) {
+                        mkdirSync(targetFileDir, { recursive: true });
+                    }
+                    cpSync(baseFilePath, targetFilePath);
+                }
+            }
+            await appendToFile(patchSourceFilePath, targetFilePath, targetAppendPath);
+        }
+        else {
+            // Normal file operation - add/update/merge
+            const patchFilePath = join(templatePath, relativePath);
+            // Use target app path to ensure all features write to same location
+            const targetFilePath = join(targetDir, targetPath);
+            // Determine if this should be merged (only for the routes file)
+            // The routeFilePath from config includes the full path from template root
+            const shouldMerge = mappedPath === routeFilePath;
+            // For route merging with dependencies:
+            // - Use target file as base if it exists (accumulates routes from previous features)
+            // - Otherwise use base app file (first feature merges with base app)
+            // Create a temp copy of target to avoid ts-morph issues with same file as base and target
+            let baseFilePath = join(baseAppPath, translatedPath);
+            let tempFilePath;
+            if (shouldMerge && existsSync(targetFilePath)) {
+                // Create temp copy of target to use as base
+                tempFilePath = join(tmpdir(), `route-merge-${randomBytes(8).toString("hex")}.tsx`);
+                cpSync(targetFilePath, tempFilePath);
+                baseFilePath = tempFilePath;
+            }
+            try {
+                await applyFile(patchFilePath, baseFilePath, targetFilePath, targetPath, shouldMerge, targetAppName);
+            }
+            finally {
+                // Clean up temp file
+                if (tempFilePath && existsSync(tempFilePath)) {
+                    rmSync(tempFilePath, { force: true });
+                }
+            }
+        }
+    }
+}
+/**
+ * Recursively rename any files or directories that have leading/trailing whitespace.
+ * Windows rejects filenames with trailing spaces, so this prevents cross-platform issues
+ * when the output is published to npm and cloned on Windows.
+ */
+function sanitizeFilenames(dir) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const trimmed = entry.name.trim();
+        const srcPath = join(dir, entry.name);
+        if (trimmed !== entry.name) {
+            const destPath = join(dir, trimmed);
+            if (trimmed.length === 0) {
+                rmSync(srcPath, { recursive: true, force: true });
+                logger.warn(`Removed file/dir with whitespace-only name in ${dir}`);
+                continue;
+            }
+            renameSync(srcPath, destPath);
+            logger.warn(`Renamed "${entry.name}" → "${trimmed}" (stripped whitespace)`);
+            if (entry.isDirectory()) {
+                sanitizeFilenames(destPath);
+            }
+        }
+        else if (entry.isDirectory()) {
+            sanitizeFilenames(srcPath);
+        }
+    }
+}
+/**
+ * Sync base template .a4drules/ and copy feature-specific markdown rules to the target directory.
+ * 1. Syncs base template .a4drules/ from the SFDX project template.
+ * 2. Copies feature rules from feature/rules/*.md to .a4drules/features/ (prefixed by feature name).
+ */
+function copyFeatureRulesAndSyncA4drules(targetDir) {
+    const targetFeaturesDir = join(targetDir, ".a4drules", "features");
+    // Sync base template .a4drules/
+    const sfdxTemplatePath = getSfdxProjectTemplatePath();
+    const sfdxA4dRulesPath = join(sfdxTemplatePath, ".a4drules");
+    if (existsSync(sfdxA4dRulesPath)) {
+        const targetA4dRulesPath = join(targetDir, ".a4drules");
+        cpSync(sfdxA4dRulesPath, targetA4dRulesPath, { recursive: true });
+        sanitizeFilenames(targetA4dRulesPath);
+        logger.success("Synced base template .a4drules/");
+    }
+    const featuresDir = getFeaturesDir();
+    if (!existsSync(featuresDir)) {
+        return;
+    }
+    const featureFolders = readdirSync(featuresDir, { withFileTypes: true });
+    let copiedRules = 0;
+    for (const folder of featureFolders) {
+        if (!folder.isDirectory())
+            continue;
+        const featureName = folder.name.trim();
+        const patchDir = join(featuresDir, folder.name);
+        // Copy rules from feature/rules/ directory (prefixed by feature name to avoid overwrites)
+        const featureRulesDir = join(patchDir, "rules");
+        if (existsSync(featureRulesDir)) {
+            const ruleFiles = readdirSync(featureRulesDir, { withFileTypes: true });
+            for (const entry of ruleFiles) {
+                if (entry.isFile() && entry.name.endsWith(".md")) {
+                    const sourceRulePath = join(featureRulesDir, entry.name);
+                    const prefixedRuleName = `${featureName}-${entry.name.trim()}`;
+                    const targetRulePath = join(targetFeaturesDir, prefixedRuleName);
+                    // Create features directory if needed
+                    if (!existsSync(targetFeaturesDir)) {
+                        mkdirSync(targetFeaturesDir, { recursive: true });
+                    }
+                    cpSync(sourceRulePath, targetRulePath);
+                    logger.info(`Copied rule: features/${prefixedRuleName}`);
+                    copiedRules++;
+                }
+            }
+        }
+    }
+    if (copiedRules > 0) {
+        logger.success(`Copied ${copiedRules} rule(s) to .a4drules/features/`);
+    }
+}
+/**
+ * Apply feature patches to create a new app
+ *
+ * @param patchPath - Path to the feature directory containing patches.ts
+ * @param appPath - Path to the base app directory (used as reference, remains unchanged)
+ * @param options - Configuration options
+ * @param options.targetDirName - Required. Target directory where feature will be applied
+ * @param options.skipDependencyChanges - Optional. Skip npm dependency installation
+ * @param options.reset - Optional. Reset target directory to base app state before applying (preserves node_modules)
+ *
+ * @example
+ * await applyPatchesCommand(
+ *   'packages/feature-navigation-menu',
+ *   'packages/base-react-app',
+ *   { targetDirName: 'my-app' }
+ * );
+ */
+export async function applyPatchesCommand(patchPath, appPath, options) {
+    try {
+        logger.heading(`Applying patches: ${patchPath} → ${options.targetDirName}`);
+        // Step 1: Validate inputs
+        logger.info("Validating paths...");
+        validateAndResolveFeaturePath(patchPath); // Fast-fail validation
+        const baseAppPath = validateAndResolveAppPath(appPath);
+        logger.success("Validation passed");
+        // Step 2: Prepare target directory
+        // Extract target app name from the main feature path for nested structure
+        const mainFeatureName = basename(patchPath);
+        const targetAppName = mainFeatureName;
+        // Resolve target directory - if absolute, use as-is; otherwise resolve relative to monorepo root
+        const resolvedTargetDir = isAbsolute(options.targetDirName)
+            ? options.targetDirName
+            : join(getMonorepoRoot(), options.targetDirName);
+        // Calculate target app directory path (SFDX structure so deploy has meta xml, uibundle.json, etc.)
+        const targetAppDir = join(resolvedTargetDir, "force-app", "main", "default", "uiBundles", targetAppName);
+        if (existsSync(resolvedTargetDir)) {
+            if (options.reset) {
+                // Reset target to base app state (preserving node_modules)
+                resetTargetToBaseApp(resolvedTargetDir, baseAppPath, targetAppName);
+            }
+        }
+        else {
+            logger.info(`Creating target directory ${options.targetDirName}...`);
+            mkdirSync(resolvedTargetDir, { recursive: true });
+            logger.success("Target directory created");
+            // Copy SFDX project template base (config/, sfdx-project.json, .forceignore, etc.) into target
+            const sfdxTemplatePath = getSfdxProjectTemplatePath();
+            if (existsSync(sfdxTemplatePath)) {
+                logger.info(`Copying SFDX project template base to ${options.targetDirName}...`);
+                cpSync(sfdxTemplatePath, resolvedTargetDir, {
+                    recursive: true,
+                    filter: (src) => !src.includes("node_modules"),
+                });
+                logger.success("SFDX project template base copied");
+            }
+            // Copy base app to target directory with nested structure
+            logger.info(`Copying base app to ${options.targetDirName}...`);
+            const sourceUIBundlePath = getUIBundlePath(baseAppPath);
+            mkdirSync(dirname(targetAppDir), { recursive: true });
+            cpSync(sourceUIBundlePath, targetAppDir, {
+                recursive: true,
+                filter: (src) => !src.includes("node_modules"),
+            });
+            processUIBundleMetaInDir(targetAppDir, targetAppName);
+            logger.success("Base app copied");
+        }
+        const targetDir = resolvedTargetDir;
+        // Step 3: Resolve dependencies
+        logger.heading("\nResolving Dependencies");
+        const { orderedPatches } = await resolveDependencies(patchPath);
+        if (orderedPatches.length > 1) {
+            logger.info(`Resolved dependency chain (${orderedPatches.length} patches):`);
+            for (let i = 0; i < orderedPatches.length; i++) {
+                const { patchPath: path } = orderedPatches[i];
+                const isMainPatch = i === orderedPatches.length - 1;
+                const prefix = isMainPatch ? "└─" : "├─";
+                const label = isMainPatch ? " (main)" : " (dependency)";
+                logger.info(`  ${prefix} ${path}${label}`);
+            }
+            logger.success("Dependency resolution complete");
+        }
+        else {
+            logger.info("No dependencies found");
+        }
+        // Step 4: Apply all patches in dependency order
+        for (const resolvedPatch of orderedPatches) {
+            await applySinglePatch(resolvedPatch, baseAppPath, targetDir, targetAppName);
+        }
+        // Step 4b: Copy site-container metadata from template if main patch has siteContainer
+        const mainPatch = orderedPatches[orderedPatches.length - 1];
+        if (mainPatch?.config.siteContainer) {
+            const siteContainerTemplatePath = getSiteContainerTemplatePath();
+            const targetForceAppDefault = join(targetDir, "force-app", "main", "default");
+            if (existsSync(siteContainerTemplatePath)) {
+                logger.info("Copying site-container metadata from template-site-container...");
+                copySiteContainerTemplate(siteContainerTemplatePath, targetForceAppDefault, targetAppName);
+                logger.success("Site-container metadata applied");
+            }
+            const metaFilePath = join(targetAppDir, `${targetAppName}.uibundle-meta.xml`);
+            if (existsSync(metaFilePath)) {
+                let content = readFileSync(metaFilePath, "utf-8");
+                if (!content.includes("<target>")) {
+                    content = content.replace("</UIBundle>", "    <target>Experience</target>\n</UIBundle>");
+                    writeFileSync(metaFilePath, content, "utf-8");
+                    logger.success("Added Experience target to UI Bundle metadata");
+                }
+            }
+        }
+        // Step 5: Aggregate and install all dependencies once
+        if (options.skipDependencyChanges) {
+            logger.info("\n⏭  Skipping dependency installation");
+        }
+        else {
+            // Aggregate all dependencies from all resolved patches, checking for conflicts
+            const aggregatedDependencies = {};
+            const aggregatedDevDependencies = {};
+            // Collect all patches from all resolved patches
+            const allPatches = orderedPatches.flatMap((rf) => rf.config.patches);
+            // First pass: collect all regular dependencies
+            for (const patch of allPatches) {
+                if (patch.packageJson?.dependencies) {
+                    for (const [name, version] of Object.entries(patch.packageJson.dependencies)) {
+                        if (aggregatedDependencies[name] && aggregatedDependencies[name] !== version) {
+                            throw new Error(`Dependency version conflict for '${name}': patch requires '${version}' but another patch requires '${aggregatedDependencies[name]}'`);
+                        }
+                        aggregatedDependencies[name] = version;
+                    }
+                }
+            }
+            // Second pass: collect dev dependencies (skip if already in dependencies)
+            for (const patch of allPatches) {
+                if (patch.packageJson?.devDependencies) {
+                    for (const [name, version] of Object.entries(patch.packageJson.devDependencies)) {
+                        // Skip if already in regular dependencies
+                        if (aggregatedDependencies[name]) {
+                            continue;
+                        }
+                        if (aggregatedDevDependencies[name] && aggregatedDevDependencies[name] !== version) {
+                            throw new Error(`Dev dependency version conflict for '${name}': patch requires '${version}' but another patch requires '${aggregatedDevDependencies[name]}'`);
+                        }
+                        aggregatedDevDependencies[name] = version;
+                    }
+                }
+            }
+            const hasAnyDependencies = Object.keys(aggregatedDependencies).length > 0 ||
+                Object.keys(aggregatedDevDependencies).length > 0;
+            if (hasAnyDependencies) {
+                logger.heading("\nMerging Dependencies");
+                await mergePackageJson(targetDir, {
+                    dependencies: Object.keys(aggregatedDependencies).length > 0 ? aggregatedDependencies : undefined,
+                    devDependencies: Object.keys(aggregatedDevDependencies).length > 0
+                        ? aggregatedDevDependencies
+                        : undefined,
+                }, targetAppDir);
+            }
+            else {
+                logger.info("\n✓ No dependencies to merge");
+            }
+            logger.heading("\nInstalling Dependencies");
+            rewriteWorkspaceDepsToLocalPaths(targetAppDir, getMonorepoRoot());
+            execSync("npm install", { cwd: targetAppDir, stdio: "inherit" });
+        }
+        // Step 6: Sync .a4drules and copy feature rules to target directory
+        logger.heading("\nSyncing .a4drules & Feature Rules");
+        copyFeatureRulesAndSyncA4drules(targetDir);
+        // Step 7: Run GraphQL codegen (only when schema.graphql exists — e.g. after graphql:schema)
+        // In CI or when schema is not checked in, skip so build succeeds.
+        const schemaPath = join(targetDir, "schema.graphql");
+        const schemaExists = existsSync(schemaPath);
+        logger.heading("\nRunning GraphQL Codegen");
+        if (schemaExists) {
+            try {
+                execSync("npm run graphql:codegen", { cwd: targetAppDir, stdio: "inherit" });
+                logger.success("GraphQL codegen complete");
+            }
+            catch {
+                logger.warning("GraphQL codegen failed — skipping");
+            }
+        }
+        else {
+            logger.info("schema.graphql not found — skipping codegen (run graphql:schema when needed)");
+        }
+        // Step 8: Success message
+        logger.heading("\n✓ Success");
+        logger.success(`Created: ${targetDir}`);
+    }
+    catch (err) {
+        // Only log error if it's not already been logged (check for our custom error messages)
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const skipLogging = [
+            "Path conflict - cannot proceed",
+            "Delete validation failed - cannot proceed",
+            "Inherit validation failed - cannot proceed",
+            "Prepend validation failed - cannot proceed",
+            "Append validation failed - cannot proceed",
+            "Route deletion failed - cannot proceed",
+        ].includes(errorMessage);
+        if (!skipLogging) {
+            logger.error(`Failed to apply feature: ${errorMessage}`);
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=apply-patches.js.map