stackkit 0.2.8 → 0.3.0

package/dist/lib/generation/code-generator.js

@@ -46,6 +46,25 @@ class AdvancedCodeGenerator {
         this.createdFiles = [];
         this.frameworkConfig = frameworkConfig;
     }
+    initializeContext(selectedModules, features) {
+        const context = {
+            ...selectedModules,
+            features,
+            combo: `${selectedModules.database || ""}:${selectedModules.framework || ""}`,
+        };
+        if (selectedModules.database === "prisma" && !context.prismaProvider) {
+            const providers = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
+            if (providers.length > 0) {
+                context.prismaProvider = providers[0];
+            }
+        }
+        return context;
+    }
+    isGeneratorSelected(genType, name, selectedModules) {
+        return ((genType === "framework" && name === selectedModules.framework) ||
+            (genType === "database" && name === selectedModules.database) ||
+            (genType === "auth" && name === selectedModules.auth));
+    }
     async loadGenerators(modulesPath) {
         const moduleTypes = ["auth", "database"];
         for (const type of moduleTypes) {
@@ -62,7 +81,7 @@ class AdvancedCodeGenerator {
                             this.generators.set(`${type}:${moduleName}`, config);
                         }
                         catch {
-                            // ignore invalid generator files
+                            continue;
                         }
                     }
                 }
@@ -96,15 +115,10 @@ class AdvancedCodeGenerator {
         return true;
     }
     processTemplate(content, context) {
-        // Create a copy of context for template variables
         const templateContext = { ...context };
-        // Handle variable definitions {{#var name = value}} at the top of the file
         content = this.processVariableDefinitions(content, templateContext);
-        // Process the rest of the template with the extended context
         content = this.processTemplateRecursive(content, templateContext);
-        // Remove leading newlines that might be left from {{#var}} removal
         content = content.replace(/^\n+/, "");
-        // Reduce multiple consecutive newlines to maximum 2
         content = content.replace(/\n{3,}/g, "\n\n");
         return content;
     }
@@ -128,15 +142,13 @@ class AdvancedCodeGenerator {
             const varNameMatch = result.substring(varStart + 7, equalsIndex).trim();
             if (!varNameMatch)
                 break;
-            // Find the end of the variable value by counting braces
-            // Start with braceCount = 1 because {{#var is already open
             let braceCount = 1;
             const valueStart = equalsIndex + 1;
             let valueEnd = valueStart;
             for (let i = valueStart; i < result.length; i++) {
                 if (result[i] === "{" && result[i + 1] === "{") {
                     braceCount++;
-                    i++; // Skip next character
+                    i++;
                 }
                 else if (result[i] === "}" && result[i + 1] === "}") {
                     braceCount--;
@@ -144,17 +156,15 @@ class AdvancedCodeGenerator {
                         valueEnd = i;
                         break;
                     }
-                    i++; // Skip next character
+                    i++;
                 }
             }
             if (valueEnd === valueStart)
                 break;
             const varValue = result.substring(valueStart, valueEnd).trim();
             const fullMatch = result.substring(varStart, valueEnd + 2);
-            // Process the variable value with current context (allowing nested variables/conditionals)
             const processedValue = this.processTemplateRecursive(varValue, context);
             context[varNameMatch] = processedValue;
-            // Remove the variable definition
             result = result.replace(fullMatch, "");
             index = varStart;
         }
@@ -189,7 +199,6 @@ class AdvancedCodeGenerator {
                 .replace(/^\n+/, "")
                 .replace(/\n+$/, "");
         });
-        // Handle simple conditional blocks {{#if condition}}...{{/if}} (backward compatibility)
         content = content.replace(/\{\{#if\s+([^}]+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (match, condition, blockContent, elseContent) => {
             const conditionParts = condition.split("==");
             if (conditionParts.length === 2) {
@@ -211,10 +220,8 @@ class AdvancedCodeGenerator {
             }
             return "";
         });
-        // Handle switch statements {{#switch variable}}...{{/switch}}
         content = content.replace(/\{\{#switch\s+([^}]+)\}\}([\s\S]*?)\{\{\/switch\}\}/g, (match, varName, switchContent) => {
             const actualVal = context[varName.trim()];
-            // Parse cases
             const caseRegex = /\{\{#case\s+([^}]+)\}\}([\s\S]*?)(?=\{\{#case|\{\{\/case\}|\{\{\/switch\})/g;
             let result = "";
             let defaultCase = "";
@@ -233,10 +240,8 @@ class AdvancedCodeGenerator {
             const chosen = (result || defaultCase || "").trim();
             return this.processTemplateRecursive(chosen, context);
         });
-        // Handle variable replacement with advanced expressions
         content = content.replace(/\{\{([^}]+)\}\}/g, (match, varExpr) => {
             const trimmedExpr = varExpr.trim();
-            // Handle ternary expressions like framework=='nextjs' ? '@/lib' : '.'
             const ternaryMatch = trimmedExpr.match(/^(.+?)\s*\?\s*(.+?)\s*:\s*(.+?)$/);
             if (ternaryMatch) {
                 const [, condition, trueVal, falseVal] = ternaryMatch;
@@ -247,10 +252,9 @@ class AdvancedCodeGenerator {
                     const cleanExpectedVal = expectedVal.trim().replace(/['"]/g, "");
                     const actualVal = context[cleanVarName];
                     const result = actualVal === cleanExpectedVal ? trueVal.trim() : falseVal.trim();
-                    return result.replace(/['"]/g, ""); // Remove quotes from result
+                    return result.replace(/['"]/g, "");
                 }
             }
-            // Handle switch expressions {{switch variable case1: value1, case2: value2, default: defaultValue}}
             const switchMatch = trimmedExpr.match(/^switch\s+([^}\s]+)\s+(.+)$/);
             if (switchMatch) {
                 const [, varName, casesStr] = switchMatch;
@@ -265,17 +269,14 @@ class AdvancedCodeGenerator {
                 }
                 return "";
             }
-            // Handle heading helper {{heading:depthVar}} -> '#', '##', ... up to '######'
             if (trimmedExpr.startsWith("heading:")) {
                 return this.renderHeadingFromExpr(trimmedExpr, context);
             }
-            // Handle feature flags {{feature:name}}
             if (trimmedExpr.startsWith("feature:")) {
                 const featureName = trimmedExpr.substring(8).trim();
                 const features = Array.isArray(context.features) ? context.features : [];
                 return features.includes(featureName) ? "true" : "false";
             }
-            // Handle conditional expressions {{if condition then:value else:value}}
             const conditionalMatch = trimmedExpr.match(/^if\s+(.+?)\s+then:([^,]+),\s*else:(.+)$/);
             if (conditionalMatch) {
                 const [, condition, thenVal, elseVal] = conditionalMatch;
@@ -289,50 +290,23 @@ class AdvancedCodeGenerator {
                     return result.replace(/['"]/g, "");
                 }
             }
-            // Simple variable replacement
             const value = context[trimmedExpr];
             return value !== undefined ? String(value) : match;
         });
         return content;
     }
     async generate(selectedModules, features, outputPath) {
-        // First, copy the base template
         await this.copyTemplate(selectedModules.framework, outputPath);
-        const context = {
-            ...selectedModules,
-            features,
-        };
-        // Derived combined key to simplify template conditionals (e.g. "prisma:express")
-        context.combo = `${context.database || ""}:${context.framework || ""}`;
-        // Set default prismaProvider if database is prisma but no provider specified
-        if (selectedModules.database === "prisma" && !context.prismaProvider) {
-            const providers = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
-            if (providers && providers.length > 0) {
-                context.prismaProvider = providers[0];
-            }
-        }
-        // Collect all applicable operations
+        const context = this.initializeContext(selectedModules, features);
         const applicableOperations = [];
         for (const [key, generator] of this.generators) {
             const [genType, name] = key.split(":");
-            // Check if this generator is selected
-            if (genType === "framework" && name === selectedModules.framework) {
-                // Framework is always included
-            }
-            else if (genType === "database" && name === selectedModules.database) {
-                // Database is selected
-            }
-            else if (genType === "auth" && name === selectedModules.auth) {
-                // Auth is selected
-            }
-            else {
-                continue; // Skip unselected generators
+            if (!this.isGeneratorSelected(genType, name, selectedModules)) {
+                continue;
             }
-            // Collect postInstall commands from selected generators
             if (generator.postInstall && Array.isArray(generator.postInstall)) {
                 this.postInstallCommands.push(...generator.postInstall);
             }
-            // Handle operations
             const items = generator.operations || [];
             for (const item of items) {
                 if (this.evaluateCondition(item.condition, context)) {
@@ -345,25 +319,21 @@ class AdvancedCodeGenerator {
                 }
             }
         }
-        // Sort operations by priority
         applicableOperations.sort((a, b) => {
             const priorityA = a.priority || 0;
             const priorityB = b.priority || 0;
             return priorityA - priorityB;
         });
-        // Execute operations
         for (const operation of applicableOperations) {
             await this.executeOperation(operation, context, outputPath);
         }
-        // Generate package.json updates
-        await this.generatePackageJson(selectedModules, features, outputPath);
+        await this.generatePackageJson(selectedModules, outputPath);
         return this.postInstallCommands;
     }
     getCreatedFiles() {
         return this.createdFiles.slice();
     }
     async executeOperation(operation, context, outputPath) {
-        // Process templates in operation content
         const processedOperation = this.processOperationTemplates(operation, context);
         switch (processedOperation.type) {
             case "create-file":
@@ -373,10 +343,10 @@ class AdvancedCodeGenerator {
                 await this.executePatchFile(processedOperation, context, outputPath);
                 break;
             case "add-dependency":
-                await this.executeAddDependency(processedOperation, context, outputPath);
+                await this.executeAddDependency(processedOperation, outputPath);
                 break;
             case "add-script":
-                await this.executeAddScript(processedOperation, context, outputPath);
+                await this.executeAddScript(processedOperation, outputPath);
                 break;
             case "add-env":
                 await this.executeAddEnv(processedOperation, context, outputPath);
@@ -385,7 +355,7 @@ class AdvancedCodeGenerator {
                 this.executeRunCommand(processedOperation, context);
                 break;
             default:
-            // Unknown operation type - skip silently
+                return;
         }
     }
     async copyTemplate(frameworkName, outputPath) {
@@ -400,20 +370,6 @@ class AdvancedCodeGenerator {
                         !relativePath.startsWith("node_modules/"));
                 },
             });
-            // If template provides a .env.example, create a .env from it when
-            // the target project does not already have a .env file.
-            try {
-                const envExampleSrc = path.join(templatePath, ".env.example");
-                const envDest = path.join(outputPath, ".env");
-                if ((await fs.pathExists(envExampleSrc)) && !(await fs.pathExists(envDest))) {
-                    await fs.copy(envExampleSrc, envDest);
-                }
-            }
-            catch {
-                // ignore (not critical)
-            }
-            // Ensure gitignore is present in target even if template authors
-            // renamed it to avoid npm/package issues (e.g. 'gitignore' or '_gitignore')
             try {
                 const gitCandidates = [".gitignore", "gitignore", "_gitignore"];
                 for (const g of gitCandidates) {
@@ -427,10 +383,9 @@ class AdvancedCodeGenerator {
                     }
                 }
             }
-            catch {
-                // ignore
+            catch (error) {
+                void error;
             }
-            // Ensure any top-level dotfiles declared in template.json are created
             try {
                 const templateJsonPath = path.join(templatePath, "template.json");
                 if (await fs.pathExists(templateJsonPath)) {
@@ -440,8 +395,7 @@ class AdvancedCodeGenerator {
                             if (typeof f === "string" && f.startsWith(".")) {
                                 const targetDest = path.join(outputPath, f);
                                 if (await fs.pathExists(targetDest))
-                                    continue; // already present
-                                // Special-case: allow creating .gitignore from non-dot fallbacks
+                                    continue;
                                 if (f === ".gitignore") {
                                     const nameWithoutDot = f.slice(1);
                                     const candidates = [f, nameWithoutDot, `_${nameWithoutDot}`];
@@ -454,9 +408,6 @@ class AdvancedCodeGenerator {
                                     }
                                     continue;
                                 }
-                                // For other dotfiles (e.g. .env.example), only create if the template
-                                // actually contains a dotfile source. Don't synthesize from non-dot fallbacks
-                                // to avoid creating files unintentionally.
                                 const srcDot = path.join(templatePath, f);
                                 if (await fs.pathExists(srcDot)) {
                                     await fs.copy(srcDot, targetDest);
@@ -466,8 +417,8 @@ class AdvancedCodeGenerator {
                     }
                 }
             }
-            catch {
-                // ignore
+            catch (error) {
+                void error;
             }
             try {
                 const templateJsonPath2 = path.join(templatePath, "template.json");
@@ -480,7 +431,6 @@ class AdvancedCodeGenerator {
                                 const nameWithoutDot = f.slice(1);
                                 const nonDot = path.join(outputPath, nameWithoutDot);
                                 const underscore = path.join(outputPath, `_${nameWithoutDot}`);
-                                // If dot already exists, remove non-dot fallbacks
                                 if (await fs.pathExists(dotDest)) {
                                     if (await fs.pathExists(nonDot)) {
                                         await fs.remove(nonDot);
@@ -490,7 +440,6 @@ class AdvancedCodeGenerator {
                                     }
                                     continue;
                                 }
-                                // If dot doesn't exist but a non-dot fallback was copied, rename it
                                 if (await fs.pathExists(nonDot)) {
                                     await fs.move(nonDot, dotDest, { overwrite: true });
                                 }
@@ -502,14 +451,23 @@ class AdvancedCodeGenerator {
                     }
                 }
             }
-            catch {
-                // ignore
+            catch (error) {
+                void error;
+            }
+            try {
+                const envExampleDest = path.join(outputPath, ".env.example");
+                const envDest = path.join(outputPath, ".env");
+                if ((await fs.pathExists(envExampleDest)) && !(await fs.pathExists(envDest))) {
+                    await fs.copy(envExampleDest, envDest);
+                }
+            }
+            catch (error) {
+                void error;
             }
         }
     }
     processOperationTemplates(operation, context) {
         const processed = { ...operation };
-        // Process templates in string fields
         if (processed.source) {
             processed.source = this.processTemplate(processed.source, context);
         }
@@ -519,7 +477,6 @@ class AdvancedCodeGenerator {
         if (processed.content) {
             processed.content = this.processTemplate(processed.content, context);
         }
-        // Process templates in patch operations
         if (processed.operations) {
             processed.operations = processed.operations.map((op) => {
                 const processedOp = { ...op };
@@ -559,90 +516,162 @@ class AdvancedCodeGenerator {
     async executeCreateFile(operation, context, outputPath) {
         if (!operation.destination)
             return;
-        const destinationPath = path.join(outputPath, this.processTemplate(operation.destination, context));
-        // Ensure directory exists
-        await fs.ensureDir(path.dirname(destinationPath));
-        let content;
+        const processedDestination = this.processTemplate(operation.destination, context);
+        const { basePath: destinationBasePath, mode: destinationMode } = this.parsePathPattern(processedDestination);
         if (operation.content) {
-            // Use content directly
-            content = this.processTemplate(operation.content, context);
-        }
-        else if (operation.source) {
-            const sourcePath = (0, generator_utils_1.locateOperationSource)(operation.generatorType, operation.generator, operation.source || "");
-            if (sourcePath && (await fs.pathExists(sourcePath))) {
-                content = await fs.readFile(sourcePath, "utf-8");
-                content = this.processTemplate(content, context);
+            const destinationPath = path.join(outputPath, processedDestination);
+            await fs.ensureDir(path.dirname(destinationPath));
+            const content = this.processTemplate(operation.content, context);
+            await fs.writeFile(destinationPath, content, "utf-8");
+            try {
+                const rel = path.relative(outputPath, destinationPath);
+                if (rel && !this.createdFiles.includes(rel))
+                    this.createdFiles.push(rel);
             }
-            else {
-                throw new Error(`Source file not found: ${sourcePath}`);
+            catch (error) {
+                void error;
             }
+            return;
         }
-        else {
+        if (!operation.source) {
             throw new Error(`Create file operation must have either 'content' or 'source' field`);
         }
-        // Write destination file
+        const processedSource = this.processTemplate(operation.source, context);
+        const { basePath: sourceBasePathRel, mode: sourceMode } = this.parsePathPattern(processedSource);
+        const sourcePath = (0, generator_utils_1.locateOperationSource)(operation.generatorType, operation.generator, sourceBasePathRel);
+        if (!sourcePath || !(await fs.pathExists(sourcePath))) {
+            throw new Error(`Source file not found: ${sourcePath}`);
+        }
+        const sourceStat = await fs.stat(sourcePath);
+        const shouldCreateMultipleFiles = sourceStat.isDirectory() || sourceMode !== "single";
+        if (shouldCreateMultipleFiles) {
+            if (!sourceStat.isDirectory()) {
+                throw new Error(`Source path must be a directory for wildcard copy: ${processedSource}`);
+            }
+            let sourceFiles = [];
+            if (sourceMode === "flat") {
+                const entries = await fs.readdir(sourcePath);
+                for (const entry of entries) {
+                    const candidatePath = path.join(sourcePath, entry);
+                    const candidateStat = await fs.stat(candidatePath);
+                    if (candidateStat.isFile()) {
+                        sourceFiles.push(candidatePath);
+                    }
+                }
+            }
+            else {
+                sourceFiles = await this.collectFilesRecursively(sourcePath);
+            }
+            for (const sourceFilePath of sourceFiles) {
+                let relativeDestinationPath;
+                if (destinationMode === "recursive") {
+                    relativeDestinationPath = path.relative(sourcePath, sourceFilePath);
+                }
+                else if (destinationMode === "flat") {
+                    relativeDestinationPath = path.basename(sourceFilePath);
+                }
+                else {
+                    relativeDestinationPath =
+                        sourceMode === "flat"
+                            ? path.basename(sourceFilePath)
+                            : path.relative(sourcePath, sourceFilePath);
+                }
+                const destinationPath = path.join(outputPath, destinationBasePath, relativeDestinationPath);
+                await fs.ensureDir(path.dirname(destinationPath));
+                let content = await fs.readFile(sourceFilePath, "utf-8");
+                content = this.processTemplate(content, context);
+                await fs.writeFile(destinationPath, content, "utf-8");
+                try {
+                    const rel = path.relative(outputPath, destinationPath);
+                    if (rel && !this.createdFiles.includes(rel))
+                        this.createdFiles.push(rel);
+                }
+                catch (error) {
+                    void error;
+                }
+            }
+            return;
+        }
+        const destinationPath = destinationMode === "single"
+            ? path.join(outputPath, processedDestination)
+            : path.join(outputPath, destinationBasePath, path.basename(sourcePath));
+        await fs.ensureDir(path.dirname(destinationPath));
+        let content = await fs.readFile(sourcePath, "utf-8");
+        content = this.processTemplate(content, context);
         await fs.writeFile(destinationPath, content, "utf-8");
         try {
             const rel = path.relative(outputPath, destinationPath);
             if (rel && !this.createdFiles.includes(rel))
                 this.createdFiles.push(rel);
         }
-        catch {
-            // ignore logging failures
+        catch (error) {
+            void error;
         }
     }
+    parsePathPattern(inputPath) {
+        const normalizedPath = inputPath.replace(/\\/g, "/");
+        if (normalizedPath.endsWith("/**")) {
+            return { basePath: normalizedPath.slice(0, -3), mode: "recursive" };
+        }
+        if (normalizedPath.endsWith("/*")) {
+            return { basePath: normalizedPath.slice(0, -2), mode: "flat" };
+        }
+        return { basePath: normalizedPath, mode: "single" };
+    }
+    async collectFilesRecursively(rootDirPath) {
+        const files = [];
+        const entries = await fs.readdir(rootDirPath);
+        for (const entry of entries) {
+            const fullPath = path.join(rootDirPath, entry);
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory()) {
+                files.push(...(await this.collectFilesRecursively(fullPath)));
+            }
+            else if (stat.isFile()) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
     async executePatchFile(operation, context, outputPath) {
         if (!operation.destination)
             return;
         const filePath = path.join(outputPath, this.processTemplate(operation.destination, context));
-        // Read existing file
         let content = await fs.readFile(filePath, "utf-8");
         if (operation.content) {
             content += this.processTemplate(operation.content, context).trim();
         }
         else if (operation.operations) {
-            // Execute patch operations
             for (const patchOp of operation.operations) {
                 if (!this.evaluateCondition(patchOp.condition, context))
                     continue;
                 switch (patchOp.type) {
                     case "add-import":
                         if (patchOp.imports) {
-                            // Process imports and trim any accidental surrounding blank lines
                             const imports = patchOp.imports
                                 .map((imp) => this.processTemplate(imp, context))
                                 .join("\n")
                                 .replace(/^\n+/, "")
                                 .replace(/\n+$/, "");
-                            // Add imports at the top, after existing imports without introducing
-                            // extra blank lines.
                             const lines = content.split("\n");
-                            // Find the last import line index
                             let lastImportIndex = -1;
                             for (let i = 0; i < lines.length; i++) {
                                 if (lines[i].trim().startsWith("import"))
                                     lastImportIndex = i;
                             }
-                            // Insert right after the last import. If there's a blank line
-                            // immediately after the imports, overwrite that blank line to
-                            // avoid introducing an extra empty line above the inserted imports.
                             const insertIndex = lastImportIndex === -1 ? 0 : lastImportIndex + 1;
-                            // Only add imports that don't already exist in the file
                             const importLines = imports
                                 .split("\n")
                                 .map((l) => l.trim())
                                 .filter(Boolean);
                             const newImportLines = importLines.filter((imp) => !lines.some((ln) => ln.trim() === imp));
                             if (newImportLines.length > 0) {
-                                // Insert imports
                                 if (insertIndex < lines.length && lines[insertIndex].trim() === "") {
                                     lines.splice(insertIndex, 1, ...newImportLines);
                                 }
                                 else {
                                     lines.splice(insertIndex, 0, ...newImportLines);
                                 }
-                                // After insertion, ensure exactly one blank line after the import block
-                                // Find last import line index again
                                 let lastIdx = -1;
                                 for (let i = 0; i < lines.length; i++) {
                                     if (lines[i].trim().startsWith("import"))
@@ -650,12 +679,10 @@ class AdvancedCodeGenerator {
                                 }
                                 const nextIdx = lastIdx + 1;
                                 if (lastIdx !== -1) {
-                                    // Remove multiple blank lines after imports
                                     let j = nextIdx;
                                     while (j < lines.length && lines[j].trim() === "") {
                                         j++;
                                     }
-                                    // Ensure exactly one blank line after imports unless imports end at EOF
                                     if (nextIdx < lines.length) {
                                         lines.splice(nextIdx, j - nextIdx, "");
                                     }
@@ -670,22 +697,17 @@ class AdvancedCodeGenerator {
                             if (Array.isArray(codeValue))
                                 codeValue = codeValue.join("\n");
                             const processedCode = this.processTemplate(codeValue, context);
-                            // Skip insertion if the exact code already exists in the file
                             const codeTrimmed = processedCode.trim();
                             if (codeTrimmed && content.includes(codeTrimmed)) {
                                 break;
                             }
-                            // Insert after pattern if provided
                             if (patchOp.after) {
                                 const afterPattern = this.processTemplate(patchOp.after, context);
                                 const index = content.indexOf(afterPattern);
                                 if (index !== -1) {
                                     const left = content.slice(0, index + afterPattern.length);
                                     const right = content.slice(index + afterPattern.length);
-                                    // Normalize code: trim surrounding newlines and ensure single trailing newline
                                     let codeNormalized = processedCode.replace(/^\n+|\n+$/g, "") + "\n";
-                                    // If right already starts with a newline, avoid double-blank by
-                                    // removing trailing newline from codeNormalized so only one newline remains
                                     const rightStartsWithNewline = right.startsWith("\n");
                                     if (rightStartsWithNewline && codeNormalized.endsWith("\n")) {
                                         codeNormalized = codeNormalized.replace(/\n+$/, "");
@@ -694,17 +716,13 @@ class AdvancedCodeGenerator {
                                     content = left + (leftNeedsNewline ? "\n" : "") + codeNormalized + right;
                                 }
                             }
-                            // Insert before pattern if provided
                             if (patchOp.before) {
                                 const beforePattern = this.processTemplate(patchOp.before, context);
                                 const index = content.indexOf(beforePattern);
                                 if (index !== -1) {
                                     const left = content.slice(0, index);
                                     const right = content.slice(index);
-                                    // Normalize code: trim surrounding newlines and ensure single trailing newline
                                     let codeNormalized = processedCode.replace(/^\n+|\n+$/g, "") + "\n";
-                                    // If right already starts with a newline, avoid double-blank by
-                                    // removing trailing newline from codeNormalized so only one newline remains
                                     const rightStartsWithNewline = right.startsWith("\n");
                                     if (rightStartsWithNewline && codeNormalized.endsWith("\n")) {
                                         codeNormalized = codeNormalized.replace(/\n+$/, "");
@@ -764,12 +782,10 @@ class AdvancedCodeGenerator {
                 }
             }
         }
-        // Normalize excessive blank lines introduced during patching
         content = content.replace(/\n{3,}/g, "\n\n");
-        // Write back the modified content
         await fs.writeFile(filePath, content, "utf-8");
     }
-    async executeAddDependency(operation, context, outputPath) {
+    async executeAddDependency(operation, outputPath) {
         const packageJsonPath = path.join(outputPath, "package.json");
         let packageJson = {};
         if (await fs.pathExists(packageJsonPath)) {
@@ -789,7 +805,7 @@ class AdvancedCodeGenerator {
         }
         await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
     }
-    async executeAddScript(operation, context, outputPath) {
+    async executeAddScript(operation, outputPath) {
         const packageJsonPath = path.join(outputPath, "package.json");
         let packageJson = {};
         if (await fs.pathExists(packageJsonPath)) {
@@ -820,32 +836,27 @@ class AdvancedCodeGenerator {
     }
     executeRunCommand(operation, context) {
         if (operation.command) {
-            // Process template variables in the command
             const processedCommand = this.processTemplate(operation.command, context);
             this.postInstallCommands.push(processedCommand);
         }
     }
-    async generatePackageJson(selectedModules, features, outputPath) {
+    async generatePackageJson(selectedModules, outputPath) {
         const packageJsonPath = path.join(outputPath, "package.json");
         let packageJson = {};
         if (await fs.pathExists(packageJsonPath)) {
             packageJson = await fs.readJson(packageJsonPath);
         }
-        // Collect dependencies from selected generators
         const allDeps = {};
         const allDevDeps = {};
         const allScripts = {};
         for (const [key, generator] of this.generators) {
             const [type, name] = key.split(":");
-            if ((type === "framework" && name === selectedModules.framework) ||
-                (type === "database" && name === selectedModules.database) ||
-                (type === "auth" && name === selectedModules.auth)) {
-                // Dependencies and devDependencies are now provided via `add-dependency`
-                // operations. Keep merging scripts from generator configs for now.
+            if (this.isGeneratorSelected(type, name, selectedModules)) {
+                Object.assign(allDeps, generator.dependencies);
+                Object.assign(allDevDeps, generator.devDependencies);
                 Object.assign(allScripts, generator.scripts);
             }
         }
-        // Update package.json
         packageJson.dependencies = {
             ...(packageJson.dependencies || {}),
             ...allDeps,
@@ -860,36 +871,12 @@ class AdvancedCodeGenerator {
         };
         await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
     }
-    /**
-     * Apply generators to an existing project directory instead of creating a new template.
-     * This executes applicable operations and updates package.json in-place.
-     */
     async applyToProject(selectedModules, features, projectPath) {
-        const context = {
-            ...selectedModules,
-            features,
-        };
-        // Derived combined key to simplify template conditionals (e.g. "prisma:express")
-        context.combo = `${context.database || ""}:${context.framework || ""}`;
-        if (selectedModules.database === "prisma" && !context.prismaProvider) {
-            const providers = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
-            if (providers && providers.length > 0) {
-                context.prismaProvider = providers[0];
-            }
-        }
+        const context = this.initializeContext(selectedModules, features);
         const applicableOperations = [];
         for (const [key, generator] of this.generators) {
             const [genType, name] = key.split(":");
-            if (genType === "framework" && name === selectedModules.framework) {
-                // framework
-            }
-            else if (genType === "database" && name === selectedModules.database) {
-                // database
-            }
-            else if (genType === "auth" && name === selectedModules.auth) {
-                // auth
-            }
-            else {
+            if (!this.isGeneratorSelected(genType, name, selectedModules)) {
                 continue;
             }
             if (generator.postInstall && Array.isArray(generator.postInstall)) {
@@ -911,7 +898,7 @@ class AdvancedCodeGenerator {
         for (const operation of applicableOperations) {
             await this.executeOperation(operation, context, projectPath);
         }
-        await this.generatePackageJson(selectedModules, features, projectPath);
+        await this.generatePackageJson(selectedModules, projectPath);
         return this.postInstallCommands;
     }
     getAvailableGenerators() {
@@ -934,9 +921,6 @@ class AdvancedCodeGenerator {
         }
         return { frameworks, databases, auths };
     }
-    /**
-     * Register a generator config dynamically (used for modules that only provide module.json patches).
-     */
     registerGenerator(type, name, config) {
         this.generators.set(`${type}:${name}`, config);
     }