stackkit 0.1.0

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

@@ -0,0 +1,681 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvancedCodeGenerator = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+class AdvancedCodeGenerator {
+    constructor(frameworkConfig) {
+        this.generators = new Map();
+        this.postInstallCommands = [];
+        this.frameworkConfig = frameworkConfig;
+    }
+    async loadGenerators(modulesPath) {
+        const moduleTypes = ['auth', 'database'];
+        // Load module generators
+        for (const type of moduleTypes) {
+            const typePath = path.join(modulesPath, type);
+            if (await fs.pathExists(typePath)) {
+                const modules = await fs.readdir(typePath);
+                for (const moduleName of modules) {
+                    const generatorPath = path.join(typePath, moduleName, 'generator.json');
+                    if (await fs.pathExists(generatorPath)) {
+                        try {
+                            const config = await fs.readJson(generatorPath);
+                            // Also load module.json for additional metadata like postInstall
+                            const modulePath = path.join(typePath, moduleName, 'module.json');
+                            if (await fs.pathExists(modulePath)) {
+                                try {
+                                    const moduleConfig = await fs.readJson(modulePath);
+                                    if (moduleConfig.postInstall && Array.isArray(moduleConfig.postInstall)) {
+                                        // Store postInstall commands with the generator for later use
+                                        config.postInstall = moduleConfig.postInstall;
+                                    }
+                                }
+                                catch {
+                                    // Silently skip if module.json is invalid
+                                }
+                            }
+                            this.generators.set(`${type}:${moduleName}`, config);
+                        }
+                        catch {
+                            // Silently skip invalid generator files
+                        }
+                    }
+                }
+            }
+        }
+    }
+    evaluateCondition(condition, context) {
+        if (!condition)
+            return true;
+        for (const [key, value] of Object.entries(condition)) {
+            if (key === 'features') {
+                const requiredFeatures = value;
+                const contextFeatures = context.features || [];
+                if (!requiredFeatures.every(feature => contextFeatures.includes(feature))) {
+                    return false;
+                }
+            }
+            else {
+                if (Array.isArray(value)) {
+                    if (!value.includes(context[key])) {
+                        return false;
+                    }
+                }
+                else {
+                    if (context[key] !== value) {
+                        return false;
+                    }
+                }
+            }
+        }
+        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;
+    }
+    processVariableDefinitions(content, context) {
+        let result = content;
+        let index = 0;
+        while (true) {
+            const varStart = result.indexOf('{{#var ', index);
+            if (varStart === -1)
+                break;
+            const equalsIndex = result.indexOf('=', varStart);
+            if (equalsIndex === -1)
+                break;
+            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
+                }
+                else if (result[i] === '}' && result[i + 1] === '}') {
+                    braceCount--;
+                    if (braceCount === 0) {
+                        valueEnd = i;
+                        break;
+                    }
+                    i++; // Skip next character
+                }
+            }
+            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;
+        }
+        return result;
+    }
+    processTemplateRecursive(content, context) {
+        content = content.replace(/\{\{#if\s+([^}\s]+)\s+([^}\s]+)\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (match, varName, operator, expectedValue, blockContent) => {
+            const actualVal = context[varName.trim()];
+            const cleanExpectedVal = expectedValue.trim().replace(/['"]/g, '');
+            let conditionMet = false;
+            switch (operator) {
+                case '==':
+                case '===':
+                    conditionMet = actualVal === cleanExpectedVal;
+                    break;
+                case '!=':
+                case '!==':
+                    conditionMet = actualVal !== cleanExpectedVal;
+                    break;
+                case 'includes':
+                    conditionMet = Array.isArray(actualVal) && actualVal.includes(cleanExpectedVal);
+                    break;
+                case 'startsWith':
+                    conditionMet = typeof actualVal === 'string' && actualVal.startsWith(cleanExpectedVal);
+                    break;
+                case 'endsWith':
+                    conditionMet = typeof actualVal === 'string' && actualVal.endsWith(cleanExpectedVal);
+                    break;
+            }
+            return conditionMet ? this.processTemplateRecursive(blockContent, context).replace(/^\n+/, '').replace(/\n+$/, '') : '';
+        });
+        // Handle simple conditional blocks {{#if condition}}...{{/if}} (backward compatibility)
+        content = content.replace(/\{\{#if\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (match, condition, blockContent) => {
+            const conditionParts = condition.split('==');
+            if (conditionParts.length === 2) {
+                const [varName, expectedValue] = conditionParts.map((s) => s.trim().replace(/['"]/g, ''));
+                if (context[varName] === expectedValue) {
+                    return this.processTemplateRecursive(blockContent, context).replace(/^\n+/, '').replace(/\n+$/, '');
+                }
+                return '';
+            }
+            const conditionFunc = condition.split('.');
+            if (conditionFunc.length === 2 && conditionFunc[1] === 'includes') {
+                const [arrayName, item] = conditionFunc[0].split('(');
+                const itemValue = item.replace(')', '').replace(/['"]/g, '');
+                const array = context[arrayName] || [];
+                if (Array.isArray(array) && array.includes(itemValue)) {
+                    return this.processTemplateRecursive(blockContent, context).replace(/^\n+/, '').replace(/\n+$/, '');
+                }
+                return '';
+            }
+            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|\{\{\/switch\})/g;
+            let result = '';
+            let defaultCase = '';
+            let caseMatch;
+            while ((caseMatch = caseRegex.exec(switchContent)) !== null) {
+                const [, caseValue, caseContent] = caseMatch;
+                const cleanCaseValue = caseValue.trim().replace(/['"]/g, '');
+                if (cleanCaseValue === 'default') {
+                    defaultCase = caseContent;
+                }
+                else if (actualVal === cleanCaseValue) {
+                    result = caseContent;
+                    break;
+                }
+            }
+            return result || defaultCase || '';
+        });
+        // 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;
+                const conditionMatch = condition.match(/^(.+?)==(.+)$/);
+                if (conditionMatch) {
+                    const [, varName, expectedVal] = conditionMatch;
+                    const cleanVarName = varName.trim();
+                    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
+                }
+            }
+            // 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;
+                const actualVal = context[varName.trim()];
+                const cases = casesStr.split(',').map((c) => c.trim());
+                for (const caseStr of cases) {
+                    const [caseVal, result] = caseStr.split(':').map((s) => s.trim());
+                    const cleanCaseVal = caseVal.replace(/['"]/g, '');
+                    if (cleanCaseVal === actualVal || cleanCaseVal === 'default') {
+                        return result.replace(/['"]/g, '');
+                    }
+                }
+                return '';
+            }
+            // Handle feature flags {{feature:name}}
+            if (trimmedExpr.startsWith('feature:')) {
+                const featureName = trimmedExpr.substring(8);
+                const 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;
+                const conditionMatch2 = condition.match(/^(.+?)==(.+)$/);
+                if (conditionMatch2) {
+                    const [, varName, expectedVal] = conditionMatch2;
+                    const cleanVarName = varName.trim();
+                    const cleanExpectedVal = expectedVal.trim().replace(/['"]/g, '');
+                    const actualVal = context[cleanVarName];
+                    const result = actualVal === cleanExpectedVal ? thenVal.trim() : elseVal.trim();
+                    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,
+        };
+        // Set default prismaProvider if database is prisma but no provider specified
+        if (selectedModules.database === 'prisma' && !context.prismaProvider) {
+            context.prismaProvider = 'postgresql';
+        }
+        // Collect all applicable operations
+        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
+            }
+            // 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)) {
+                    applicableOperations.push({
+                        ...item,
+                        generator: name,
+                        generatorType: genType,
+                        priority: generator.priority,
+                    });
+                }
+            }
+        }
+        // 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);
+        return this.postInstallCommands;
+    }
+    async executeOperation(operation, context, outputPath) {
+        // Process templates in operation content
+        const processedOperation = this.processOperationTemplates(operation, context);
+        switch (processedOperation.type) {
+            case 'create-file':
+                await this.executeCreateFile(processedOperation, context, outputPath);
+                break;
+            case 'patch-file':
+                await this.executePatchFile(processedOperation, context, outputPath);
+                break;
+            case 'add-dependency':
+                await this.executeAddDependency(processedOperation, context, outputPath);
+                break;
+            case 'add-script':
+                await this.executeAddScript(processedOperation, context, outputPath);
+                break;
+            case 'add-env':
+                await this.executeAddEnv(processedOperation, context, outputPath);
+                break;
+            case 'run-command':
+                this.executeRunCommand(processedOperation, context);
+                break;
+            default:
+            // Unknown operation type - skip silently
+        }
+    }
+    async copyTemplate(frameworkName, outputPath) {
+        const candidates = [
+            path.resolve(__dirname, '..', '..', 'templates'), // dist/templates (when bundled)
+            path.resolve(__dirname, '..', '..', '..', 'templates'), // package root templates
+        ];
+        let templateBase;
+        for (const c of candidates) {
+            const p = path.join(c, frameworkName);
+            if (await fs.pathExists(p)) {
+                templateBase = p;
+                break;
+            }
+        }
+        if (!templateBase)
+            return;
+        await fs.copy(templateBase, outputPath, {
+            filter: (src) => {
+                const relativePath = path.relative(templateBase, src);
+                return relativePath !== 'template.json' &&
+                    relativePath !== 'node_modules' &&
+                    !relativePath.startsWith('node_modules/');
+            }
+        });
+    }
+    processOperationTemplates(operation, context) {
+        const processed = { ...operation };
+        // Process templates in string fields
+        if (processed.source) {
+            processed.source = this.processTemplate(processed.source, context);
+        }
+        if (processed.destination) {
+            processed.destination = this.processTemplate(processed.destination, context);
+        }
+        if (processed.content) {
+            processed.content = this.processTemplate(processed.content, context);
+        }
+        if (processed.destination) {
+            processed.destination = this.processTemplate(processed.destination, context);
+        }
+        // Process templates in patch operations
+        if (processed.operations) {
+            processed.operations = processed.operations.map(op => {
+                const processedOp = { ...op };
+                if (processedOp.imports) {
+                    processedOp.imports = processedOp.imports.map(imp => this.processTemplate(imp, context));
+                }
+                if (processedOp.code) {
+                    processedOp.code = this.processTemplate(processedOp.code, context);
+                }
+                if (processedOp.after) {
+                    processedOp.after = this.processTemplate(processedOp.after, context);
+                }
+                if (processedOp.before) {
+                    processedOp.before = this.processTemplate(processedOp.before, context);
+                }
+                if (processedOp.replace) {
+                    processedOp.replace = this.processTemplate(processedOp.replace, context);
+                }
+                if (processedOp.content) {
+                    processedOp.content = this.processTemplate(processedOp.content, context);
+                }
+                if (processedOp.source) {
+                    processedOp.source = this.processTemplate(processedOp.source, context);
+                }
+                return processedOp;
+            });
+        }
+        return processed;
+    }
+    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;
+        if (operation.content) {
+            // Use content directly
+            content = this.processTemplate(operation.content, context);
+        }
+        else if (operation.source) {
+            // Find the source file path relative to the module/template directory
+            // Resolve modules/templates base paths (try both dist and package root)
+            const modulesCandidates = [
+                path.resolve(__dirname, '..', '..', 'modules'),
+                path.resolve(__dirname, '..', '..', '..', 'modules'),
+            ];
+            const templatesCandidates = [
+                path.resolve(__dirname, '..', '..', 'templates'),
+                path.resolve(__dirname, '..', '..', '..', 'templates'),
+            ];
+            const resolveExisting = async (cands) => {
+                for (const c of cands) {
+                    if (await fs.pathExists(c))
+                        return c;
+                }
+                return undefined;
+            };
+            const modulesPathResolved = await resolveExisting(modulesCandidates);
+            const templatesPathResolved = await resolveExisting(templatesCandidates);
+            const moduleBasePath = operation.generatorType === 'framework'
+                ? path.join(templatesPathResolved || templatesCandidates[0], operation.generator)
+                : path.join(modulesPathResolved || modulesCandidates[0], operation.generatorType, operation.generator);
+            const sourcePath = path.join(moduleBasePath, 'files', operation.source);
+            // Check if source file exists
+            if (await fs.pathExists(sourcePath)) {
+                // Read source file
+                content = await fs.readFile(sourcePath, 'utf-8');
+                // Process template content
+                content = this.processTemplate(content, context);
+            }
+            else {
+                throw new Error(`Source file not found: ${sourcePath}`);
+            }
+        }
+        else {
+            throw new Error(`Create file operation must have either 'content' or 'source' field`);
+        }
+        // Write destination file
+        await fs.writeFile(destinationPath, content, 'utf-8');
+    }
+    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) {
+                            const imports = patchOp.imports.map(imp => this.processTemplate(imp, context)).join('\n');
+                            // Add imports at the top, after existing imports
+                            const lines = content.split('\n');
+                            let insertIndex = 0;
+                            for (let i = 0; i < lines.length; i++) {
+                                if (lines[i].trim().startsWith('import') || lines[i].trim() === '') {
+                                    insertIndex = i + 1;
+                                }
+                                else {
+                                    break;
+                                }
+                            }
+                            lines.splice(insertIndex, 0, imports);
+                            content = lines.join('\n');
+                        }
+                        break;
+                    case 'add-code':
+                        if (patchOp.code && patchOp.after) {
+                            const processedCode = this.processTemplate(patchOp.code, context);
+                            const afterPattern = this.processTemplate(patchOp.after, context);
+                            const index = content.indexOf(afterPattern);
+                            if (index !== -1) {
+                                content = content.slice(0, index + afterPattern.length) + processedCode + content.slice(index + afterPattern.length);
+                            }
+                        }
+                        break;
+                    case 'replace-code':
+                        if (patchOp.code && patchOp.replace) {
+                            const processedCode = this.processTemplate(patchOp.code, context);
+                            const replacePattern = this.processTemplate(patchOp.replace, context);
+                            content = content.replace(replacePattern, processedCode);
+                        }
+                        break;
+                    case 'add-to-top': {
+                        let processedContentTop = '';
+                        if (patchOp.content) {
+                            processedContentTop = this.processTemplate(patchOp.content, context).trim();
+                        }
+                        else if (patchOp.source) {
+                            const modulesPath = path.join(__dirname, '..', '..', 'modules');
+                            const sourcePath = path.join(modulesPath, operation.generatorType, operation.generator, 'files', patchOp.source);
+                            if (await fs.pathExists(sourcePath)) {
+                                processedContentTop = await fs.readFile(sourcePath, 'utf-8');
+                                processedContentTop = this.processTemplate(processedContentTop, context).trim();
+                            }
+                        }
+                        if (processedContentTop) {
+                            content = processedContentTop + '\n' + content;
+                        }
+                        break;
+                    }
+                    case 'add-to-bottom': {
+                        let processedContentBottom = '';
+                        if (patchOp.content) {
+                            processedContentBottom = this.processTemplate(patchOp.content, context).trim();
+                        }
+                        else if (patchOp.source) {
+                            const modulesPath = path.join(__dirname, '..', '..', 'modules');
+                            const sourcePath = path.join(modulesPath, operation.generatorType, operation.generator, 'files', patchOp.source);
+                            if (await fs.pathExists(sourcePath)) {
+                                processedContentBottom = await fs.readFile(sourcePath, 'utf-8');
+                                processedContentBottom = this.processTemplate(processedContentBottom, context).trim();
+                            }
+                        }
+                        if (processedContentBottom) {
+                            content = content + '\n' + processedContentBottom;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        // Write back the modified content
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+    async executeAddDependency(operation, context, outputPath) {
+        const packageJsonPath = path.join(outputPath, 'package.json');
+        let packageJson = {};
+        if (await fs.pathExists(packageJsonPath)) {
+            packageJson = await fs.readJson(packageJsonPath);
+        }
+        if (operation.dependencies) {
+            packageJson.dependencies = { ...(packageJson.dependencies || {}), ...operation.dependencies };
+        }
+        if (operation.devDependencies) {
+            packageJson.devDependencies = { ...(packageJson.devDependencies || {}), ...operation.devDependencies };
+        }
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    async executeAddScript(operation, context, outputPath) {
+        const packageJsonPath = path.join(outputPath, 'package.json');
+        let packageJson = {};
+        if (await fs.pathExists(packageJsonPath)) {
+            packageJson = await fs.readJson(packageJsonPath);
+        }
+        if (operation.scripts) {
+            packageJson.scripts = { ...(packageJson.scripts || {}), ...operation.scripts };
+        }
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    async executeAddEnv(operation, context, outputPath) {
+        const envPath = path.join(outputPath, '.env');
+        let envContent = '';
+        if (await fs.pathExists(envPath)) {
+            envContent = await fs.readFile(envPath, 'utf-8');
+        }
+        if (operation.envVars) {
+            const envLines = Object.entries(operation.envVars).map(([key, value]) => `${key}=${value}`);
+            envContent += '\n' + envLines.join('\n');
+        }
+        await fs.writeFile(envPath, envContent.trim(), 'utf-8');
+    }
+    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) {
+        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)) {
+                Object.assign(allDeps, generator.dependencies);
+                Object.assign(allDevDeps, generator.devDependencies);
+                Object.assign(allScripts, generator.scripts);
+            }
+        }
+        // Update package.json
+        packageJson.dependencies = { ...(packageJson.dependencies || {}), ...allDeps };
+        packageJson.devDependencies = { ...(packageJson.devDependencies || {}), ...allDevDeps };
+        packageJson.scripts = { ...(packageJson.scripts || {}), ...allScripts };
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    getAvailableGenerators() {
+        const frameworks = [];
+        const databases = [];
+        const auths = [];
+        for (const [key] of this.generators) {
+            const [type, name] = key.split(':');
+            switch (type) {
+                case 'framework':
+                    frameworks.push(name);
+                    break;
+                case 'database':
+                    databases.push(name);
+                    break;
+                case 'auth':
+                    auths.push(name);
+                    break;
+            }
+        }
+        return { frameworks, databases, auths };
+    }
+}
+exports.AdvancedCodeGenerator = AdvancedCodeGenerator;

package/dist/lib/git-utils.d.ts

@@ -0,0 +1 @@
+export declare function initGit(cwd: string): Promise<void>;