stackkit 0.1.4 → 0.1.6

package/README.md

@@ -40,4 +40,4 @@ npx stackkit doctor
 ## Documentation
 
 - [StackKit Docs](https://stackkit.tariqul.dev)
-- [GitHub Repository](https://github.com/tariqul420/stackkit)
+- [GitHub Repository](https://github.com/tariqul420/stackkit)

package/dist/cli/add.js

@@ -17,7 +17,6 @@ const logger_1 = require("../lib/ui/logger");
 const package_manager_1 = require("../lib/pm/package-manager");
 const package_root_1 = require("../lib/utils/package-root");
 const framework_utils_1 = require("../lib/framework/framework-utils");
-const generator_utils_1 = require("../lib/generation/generator-utils");
 async function addCommand(module, options) {
     try {
         const projectRoot = process.cwd();
@@ -29,10 +28,6 @@ async function addCommand(module, options) {
         logger_1.logger.newLine();
         logger_1.logger.success(`Added ${chalk_1.default.bold(config.displayName)}`);
         logger_1.logger.newLine();
-        if (config.metadata.envVars && config.metadata.envVars.length > 0) {
-            logger_1.logger.log("Next: Fill in environment variables in .env");
-        }
-        logger_1.logger.newLine();
     }
     catch (error) {
         logger_1.logger.error(`Failed to add module: ${error.message}`);
@@ -43,87 +38,60 @@ async function addCommand(module, options) {
     }
 }
 async function getAddConfig(module, options, projectInfo) {
-    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), 'modules');
-    const argv = process.argv.slice(2);
-    const addIndex = argv.indexOf('add');
-    const argsAfterAdd = addIndex >= 0 ? argv.slice(addIndex + 1) : [];
-    const flagsProvided = argsAfterAdd.some(arg => arg.startsWith('-'));
-    const optionsProvided = flagsProvided || !!(options && (options.yes || options.provider || options.force || options.dryRun));
-    if (optionsProvided) {
-        if (!module) {
-            throw new Error("Module name is required when using flags");
-        }
-        if (module === "database" || module === "auth") {
+    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules");
+    // If no module provided, go interactive
+    if (!module) {
+        return await getInteractiveConfig(modulesDir, projectInfo);
+    }
+    // Only allow: no-arg interactive, or explicit category + --provider.
+    // Disallow positional provider names like `npx stackkit add better-auth` or
+    // `npx stackkit add auth prisma-postgresql` — require `--provider` flag.
+    if (module === "database" || module === "auth") {
+        if (!options?.provider) {
             if (module === "database") {
-                if (!options?.provider) {
-                    throw new Error("Provider is required for database. Use --provider <provider>");
-                }
-                let baseProvider = options.provider;
-                let adapterProvider = options.provider;
-                if (options.provider.includes('-')) {
-                    const parts = options.provider.split('-');
-                    baseProvider = parts[0]; // e.g., "prisma"
-                    adapterProvider = options.provider; // e.g., "prisma-postgresql"
-                }
-                const moduleMetadata = await loadModuleMetadata(modulesDir, baseProvider, baseProvider);
-                if (!moduleMetadata) {
-                    throw new Error(`Database provider "${baseProvider}" not found`);
-                }
-                return {
-                    module: "database",
-                    provider: adapterProvider,
-                    displayName: `${moduleMetadata.displayName} (${adapterProvider.split('-')[1] || adapterProvider})`,
-                    metadata: moduleMetadata,
-                };
+                throw new Error('Provider is required for database. Use: `npx stackkit add database --provider <provider>`');
             }
-            else if (module === "auth") {
-                const provider = options?.provider || "better-auth";
-                const moduleMetadata = await loadModuleMetadata(modulesDir, provider, provider);
-                if (!moduleMetadata) {
-                    throw new Error(`Auth provider "${provider}" not found`);
-                }
-                return {
-                    module: "auth",
-                    provider,
-                    displayName: moduleMetadata.displayName,
-                    metadata: moduleMetadata,
-                };
+            else {
+                throw new Error('Provider is required for auth. Use: `npx stackkit add auth --provider <provider>`');
             }
         }
-        const moduleMetadata = await loadModuleMetadata(modulesDir, module, options?.provider);
-        if (!moduleMetadata) {
-            throw new Error(`Module "${module}" not found`);
-        }
-        let selectedProvider = options?.provider;
-        if (!selectedProvider && moduleMetadata.category !== module) {
-            selectedProvider = module;
-        }
-        if (moduleMetadata.category === "database" && !selectedProvider) {
-            if (typeof moduleMetadata.dependencies === "object" && "providers" in moduleMetadata.dependencies) {
-                const providers = Object.keys(moduleMetadata.dependencies.providers || {});
-                if (providers.length > 0) {
-                    const { provider } = await inquirer_1.default.prompt([
-                        {
-                            type: "list",
-                            name: "provider",
-                            message: "Select database provider:",
-                            choices: providers.map((p) => ({ name: p, value: p })),
-                        },
-                    ]);
-                    selectedProvider = provider;
-                }
+        if (module === "database") {
+            let baseProvider = options.provider;
+            let adapterProvider = options.provider;
+            if (options.provider.includes("-")) {
+                const parts = options.provider.split("-");
+                baseProvider = parts[0]; // e.g., "prisma"
+                adapterProvider = options.provider; // e.g., "prisma-postgresql"
+            }
+            const moduleMetadata = await loadModuleMetadata(modulesDir, baseProvider, baseProvider);
+            if (!moduleMetadata) {
+                throw new Error(`Database provider "${baseProvider}" not found`);
             }
+            return {
+                module: "database",
+                provider: adapterProvider,
+                displayName: `${moduleMetadata.displayName} (${adapterProvider.split("-")[1] || adapterProvider})`,
+                metadata: moduleMetadata,
+            };
         }
-        if (projectInfo && !moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
-            throw new Error(`Module "${module}" does not support ${projectInfo.framework}. Supported: ${moduleMetadata.supportedFrameworks.join(", ")}`);
+        else if (module === "auth") {
+            const provider = options.provider;
+            const moduleMetadata = await loadModuleMetadata(modulesDir, provider, provider);
+            if (!moduleMetadata) {
+                throw new Error(`Auth provider "${provider}" not found`);
+            }
+            return {
+                module: "auth",
+                provider,
+                displayName: moduleMetadata.displayName,
+                metadata: moduleMetadata,
+            };
         }
-        return {
-            module,
-            provider: selectedProvider,
-            displayName: moduleMetadata.displayName,
-            metadata: moduleMetadata,
-        };
     }
+    // Unknown module type
+    throw new Error(`Unknown module type "${module}". Use "database" or "auth", or specify a provider directly.`);
+}
+async function getInteractiveConfig(modulesDir, projectInfo) {
     const answers = await inquirer_1.default.prompt([
         {
             type: "list",
@@ -131,7 +99,7 @@ async function getAddConfig(module, options, projectInfo) {
             message: "What would you like to add?",
             choices: [
                 { name: "Database", value: "database" },
-                { name: "Authentication", value: "auth" },
+                { name: "Auth", value: "auth" },
             ],
         },
     ]);
@@ -165,9 +133,9 @@ async function getAddConfig(module, options, projectInfo) {
             ]);
             return {
                 module: "database",
-                provider: "prisma",
+                provider: `prisma-${providerAnswers.provider}`,
                 displayName: `Prisma (${providerAnswers.provider})`,
-                metadata: await loadModuleMetadata(modulesDir, "prisma", "prisma"),
+                metadata: (await loadModuleMetadata(modulesDir, "prisma", "prisma")),
             };
         }
         else {
@@ -175,7 +143,7 @@ async function getAddConfig(module, options, projectInfo) {
                 module: "database",
                 provider: "mongoose",
                 displayName: "Mongoose",
-                metadata: await loadModuleMetadata(modulesDir, "mongoose", "mongoose"),
+                metadata: (await loadModuleMetadata(modulesDir, "mongoose", "mongoose")),
             };
         }
     }
@@ -208,6 +176,55 @@ async function getAddConfig(module, options, projectInfo) {
     }
     throw new Error("Invalid selection");
 }
+async function getProviderConfig(modulesDir, provider, projectInfo) {
+    if (provider.includes("-")) {
+        const parts = provider.split("-");
+        const baseProvider = parts[0];
+        const specificProvider = provider;
+        if (baseProvider === "prisma") {
+            const metadata = await loadModuleMetadata(modulesDir, "database", baseProvider);
+            if (!metadata) {
+                throw new Error(`Database provider "${baseProvider}" not found`);
+            }
+            return {
+                module: "database",
+                provider: specificProvider,
+                displayName: `Prisma (${parts[1]})`,
+                metadata,
+            };
+        }
+    }
+    else {
+        if (provider === "mongoose") {
+            const metadata = await loadModuleMetadata(modulesDir, "database", "mongoose");
+            if (!metadata) {
+                throw new Error(`Database provider "${provider}" not found`);
+            }
+            return {
+                module: "database",
+                provider: "mongoose",
+                displayName: "Mongoose",
+                metadata,
+            };
+        }
+        else if (provider === "better-auth" || provider === "authjs") {
+            const metadata = await loadModuleMetadata(modulesDir, provider, provider);
+            if (!metadata) {
+                throw new Error(`Auth provider "${provider}" not found`);
+            }
+            if (projectInfo && !metadata.supportedFrameworks.includes(projectInfo.framework)) {
+                throw new Error(`Auth provider "${provider}" does not support ${projectInfo.framework}`);
+            }
+            return {
+                module: "auth",
+                provider,
+                displayName: provider === "better-auth" ? "Better Auth" : "Auth.js",
+                metadata,
+            };
+        }
+    }
+    throw new Error(`Unknown provider "${provider}". Available providers: better-auth, authjs, mongoose, prisma-postgresql, prisma-mongodb, prisma-mysql, prisma-sqlite`);
+}
 async function addModuleToProject(projectRoot, projectInfo, config, options) {
     const moduleMetadata = config.metadata;
     const selectedProvider = config.provider;
@@ -226,24 +243,45 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
             return;
         }
     }
+    if (config.module === "database" && projectInfo.hasDatabase && !options?.force) {
+        logger_1.logger.warn("Database library already detected in this project");
+        const { proceed } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "proceed",
+                message: "Continue anyway? (use --force to skip this prompt)",
+                default: false,
+            },
+        ]);
+        if (!proceed) {
+            logger_1.logger.info("Cancelled");
+            return;
+        }
+    }
     if (options?.dryRun) {
         logger_1.logger.warn("Dry run mode - no changes will be made");
         logger_1.logger.newLine();
     }
-    const moduleBasePath = await findModulePath(path_1.default.join((0, package_root_1.getPackageRoot)(), 'modules'), config.module, config.provider);
+    const moduleBasePath = await findModulePath(path_1.default.join((0, package_root_1.getPackageRoot)(), "modules"), config.module, config.provider);
     if (moduleBasePath) {
-        const frameworkConfig = await framework_utils_1.FrameworkUtils.loadFrameworkConfig(projectInfo.framework, path_1.default.join((0, package_root_1.getPackageRoot)(), 'templates'));
+        const frameworkConfig = await framework_utils_1.FrameworkUtils.loadFrameworkConfig(projectInfo.framework, path_1.default.join((0, package_root_1.getPackageRoot)(), "templates"));
         const gen = new code_generator_1.AdvancedCodeGenerator(frameworkConfig);
-        await gen.loadGenerators(path_1.default.join((0, package_root_1.getPackageRoot)(), 'modules'));
+        await gen.loadGenerators(path_1.default.join((0, package_root_1.getPackageRoot)(), "modules"));
         const moduleName = path_1.default.basename(moduleBasePath);
         const available = gen.getAvailableGenerators();
-        const alreadyRegistered = (config.module === 'database' && available.databases.includes(moduleName)) || (config.module === 'auth' && available.auths.includes(moduleName));
+        const alreadyRegistered = (config.module === "database" && available.databases.includes(moduleName)) ||
+            (config.module === "auth" && available.auths.includes(moduleName));
         if (!alreadyRegistered) {
             const ops = [];
             if (Array.isArray(moduleMetadata.patches)) {
                 for (const p of moduleMetadata.patches) {
-                    if (p.type === 'create-file') {
-                        ops.push({ type: 'create-file', source: p.source, destination: p.destination, condition: p.condition });
+                    if (p.type === "create-file") {
+                        ops.push({
+                            type: "create-file",
+                            source: p.source,
+                            destination: p.destination,
+                            condition: p.condition,
+                        });
                     }
                 }
             }
@@ -258,40 +296,40 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
             }
         }
         const selectedModules = { framework: projectInfo.framework };
-        if (config.module === 'database' && config.provider) {
-            if (config.provider.startsWith('prisma-')) {
-                selectedModules.database = 'prisma';
-                selectedModules.prismaProvider = config.provider.split('-')[1];
+        if (config.module === "database" && config.provider) {
+            if (config.provider.startsWith("prisma-")) {
+                selectedModules.database = "prisma";
+                selectedModules.prismaProvider = config.provider.split("-")[1];
             }
             else {
                 selectedModules.database = config.provider;
             }
         }
-        if (config.module === 'auth' && config.provider) {
+        if (config.module === "auth" && config.provider) {
             selectedModules.auth = config.provider;
         }
         const postInstall = await gen.applyToProject(selectedModules, [], projectRoot);
         if (postInstall && postInstall.length > 0 && !options?.dryRun) {
-            const postInstallSpinner = logger_1.logger.startSpinner('Running post-install commands...');
+            const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
             try {
                 for (const command of postInstall) {
-                    (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: 'pipe' });
+                    (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: "pipe" });
                 }
-                postInstallSpinner.succeed('Post-install commands completed');
+                postInstallSpinner.succeed("Post-install commands completed");
             }
             catch (error) {
-                postInstallSpinner.fail('Failed to run post-install commands');
+                postInstallSpinner.fail("Failed to run post-install commands");
                 throw error;
             }
         }
         if (!options?.dryRun && options?.install !== false) {
-            const installSpinner = logger_1.logger.startSpinner('Installing dependencies...');
+            const installSpinner = logger_1.logger.startSpinner("Installing dependencies...");
             try {
                 await (0, package_manager_1.installDependencies)(projectRoot, projectInfo.packageManager);
-                installSpinner.succeed('Dependencies installed');
+                installSpinner.succeed("Dependencies installed");
             }
             catch (err) {
-                installSpinner.fail('Failed to install dependencies');
+                installSpinner.fail("Failed to install dependencies");
                 throw err;
             }
         }
@@ -314,15 +352,18 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
     if (moduleMetadata.envVars) {
         const envArray = Array.isArray(moduleMetadata.envVars)
             ? moduleMetadata.envVars
-            : Object.entries(moduleMetadata.envVars).map(([k, v]) => ({ key: k, value: String(v) }));
+            : Object.entries(moduleMetadata.envVars).map(([k, v]) => ({
+                key: k,
+                value: String(v),
+            }));
         for (const ev of envArray) {
-            if (ev.key && typeof ev.value === 'string')
+            if (ev.key && typeof ev.value === "string")
                 variables[ev.key] = ev.value;
         }
         for (let pass = 0; pass < 5; pass++) {
             let changed = false;
             for (const ev of envArray) {
-                if (!ev.key || typeof ev.value !== 'string')
+                if (!ev.key || typeof ev.value !== "string")
                     continue;
                 const resolved = ev.value.replace(/\{\{(\w+)\}\}/g, (_m, k) => variables[k] ?? _m);
                 if (variables[ev.key] !== resolved) {
@@ -402,10 +443,10 @@ async function loadModuleMetadata(modulesDir, moduleName, provider) {
             if (await fs_extra_1.default.pathExists(metadataPath)) {
                 const metadata = await fs_extra_1.default.readJSON(metadataPath);
                 if (provider && moduleDir === provider) {
-                    return await (0, generator_utils_1.mergeGeneratorIntoModuleMetadata)(metadata, modulePath);
+                    return metadata;
                 }
                 if (!provider && (metadata.category === moduleName || moduleDir === moduleName)) {
-                    return await (0, generator_utils_1.mergeGeneratorIntoModuleMetadata)(metadata, modulePath);
+                    return metadata;
                 }
             }
         }

package/dist/cli/create.d.ts

@@ -10,10 +10,10 @@ interface CliOptions {
     packageManager?: string;
     p?: string;
     install?: boolean;
-    'skip-install'?: boolean;
+    "skip-install"?: boolean;
     skipInstall?: boolean;
     git?: boolean;
-    'no-git'?: boolean;
+    "no-git"?: boolean;
     noGit?: boolean;
     yes?: boolean;
     y?: boolean;

package/dist/cli/create.js

@@ -18,6 +18,7 @@ const framework_utils_1 = require("../lib/framework/framework-utils");
 const module_discovery_1 = require("../lib/discovery/module-discovery");
 const code_generator_1 = require("../lib/generation/code-generator");
 const package_root_1 = require("../lib/utils/package-root");
+const env_editor_1 = require("../lib/env/env-editor");
 async function createProject(projectName, options) {
     logger_1.logger.newLine();
     logger_1.logger.log(chalk_1.default.bold.cyan("📦 Create StackKit App"));
@@ -30,18 +31,19 @@ async function createProject(projectName, options) {
         process.exit(1);
     }
     await generateProject(config, targetDir, options);
+    await processGeneratorEnvVars(config, targetDir);
     showNextSteps(config);
 }
 async function getProjectConfig(projectName, options) {
-    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), 'modules');
+    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules");
     const discoveredModules = await (0, module_discovery_1.discoverModules)(modulesDir);
     const argv = process.argv.slice(2);
-    const createIndex = argv.indexOf('create');
+    const createIndex = argv.indexOf("create");
     const argsAfterCreate = createIndex >= 0 ? argv.slice(createIndex + 1) : [];
-    const flagsProvided = argsAfterCreate.some(arg => arg.startsWith('-'));
+    const flagsProvided = argsAfterCreate.some((arg) => arg.startsWith("-"));
     const optionsProvided = flagsProvided || !!(options && (options.yes || options.y));
     if (optionsProvided) {
-        if ((options && (options.yes || options.y))) {
+        if (options && (options.yes || options.y) && !flagsProvided) {
             return {
                 projectName: projectName || "my-app",
                 framework: "nextjs",
@@ -54,37 +56,37 @@ async function getProjectConfig(projectName, options) {
         }
         const framework = (options && (options.framework || options.f)) || undefined;
         if (discoveredModules.frameworks && discoveredModules.frameworks.length > 0) {
-            const validFrameworks = discoveredModules.frameworks.map(f => f.name);
+            const validFrameworks = discoveredModules.frameworks.map((f) => f.name);
             if (framework && !validFrameworks.includes(framework)) {
-                throw new Error(`Invalid framework: ${framework}. Valid options: ${validFrameworks.join(', ')}`);
+                throw new Error(`Invalid framework: ${framework}. Valid options: ${validFrameworks.join(", ")}`);
             }
         }
         const db = (options && (options.database || options.d)) || undefined;
         let allValidDatabases = [];
         if (discoveredModules.databases && discoveredModules.databases.length > 0) {
             const validDatabases = (0, module_discovery_1.getValidDatabaseOptions)(discoveredModules.databases);
-            const validBaseDatabases = discoveredModules.databases.map(db => db.name);
+            const validBaseDatabases = discoveredModules.databases.map((db) => db.name);
             allValidDatabases = [...validDatabases, ...validBaseDatabases];
             if (db && !allValidDatabases.includes(db)) {
-                throw new Error(`Invalid database: ${db}. Valid options: ${allValidDatabases.filter((v, i, arr) => arr.indexOf(v) === i).join(', ')}`);
+                throw new Error(`Invalid database: ${db}. Valid options: ${allValidDatabases.filter((v, i, arr) => arr.indexOf(v) === i).join(", ")}`);
             }
         }
         const authOpt = (options && (options.auth || options.a)) || undefined;
         if (discoveredModules.auth && discoveredModules.auth.length > 0) {
             const validAuth = (0, module_discovery_1.getValidAuthOptions)(discoveredModules.auth);
             if (authOpt && !validAuth.includes(authOpt)) {
-                throw new Error(`Invalid auth: ${authOpt}. Valid options: ${validAuth.join(', ')}`);
+                throw new Error(`Invalid auth: ${authOpt}. Valid options: ${validAuth.join(", ")}`);
             }
         }
-        const validLanguages = ['typescript', 'javascript'];
+        const validLanguages = ["typescript", "javascript"];
         const language = (options && (options.language || options.l)) || undefined;
         if (language && !validLanguages.includes(language)) {
-            throw new Error(`Invalid language: ${language}. Valid options: ${validLanguages.join(', ')}`);
+            throw new Error(`Invalid language: ${language}. Valid options: ${validLanguages.join(", ")}`);
         }
-        const validPackageManagers = ['pnpm', 'npm', 'yarn', 'bun'];
+        const validPackageManagers = ["pnpm", "npm", "yarn", "bun"];
         const pm = (options && (options.packageManager || options.p)) || undefined;
         if (pm && !validPackageManagers.includes(pm)) {
-            throw new Error(`Invalid package manager: ${pm}. Valid options: ${validPackageManagers.join(', ')}`);
+            throw new Error(`Invalid package manager: ${pm}. Valid options: ${validPackageManagers.join(", ")}`);
         }
         let database = "none";
         let prismaProvider;
@@ -136,12 +138,12 @@ async function getProjectConfig(projectName, options) {
             type: "list",
             name: "framework",
             message: "Select framework:",
-            choices: (discoveredModules.frameworks && discoveredModules.frameworks.length > 0)
-                ? discoveredModules.frameworks.map(f => ({ name: f.displayName, value: f.name }))
+            choices: discoveredModules.frameworks && discoveredModules.frameworks.length > 0
+                ? discoveredModules.frameworks.map((f) => ({ name: f.displayName, value: f.name }))
                 : [
-                    { name: 'Next.js', value: 'nextjs' },
-                    { name: 'Express.js', value: 'express' },
-                    { name: 'React (Vite)', value: 'react' },
+                    { name: "Next.js", value: "nextjs" },
+                    { name: "Express.js", value: "express" },
+                    { name: "React (Vite)", value: "react" },
                 ],
         },
         {
@@ -171,7 +173,7 @@ async function getProjectConfig(projectName, options) {
             type: "list",
             name: "auth",
             message: "Select authentication:",
-            when: (answers) => (answers.database !== "none" || answers.framework === "react"),
+            when: (answers) => answers.database !== "none" || answers.framework === "react",
             choices: (answers) => (0, module_discovery_1.getCompatibleAuthOptions)(discoveredModules.auth, answers.framework, answers.database || "none"),
         },
         {
@@ -204,7 +206,7 @@ async function getProjectConfig(projectName, options) {
             ? "none"
             : answers.database),
         prismaProvider: answers.prismaProvider,
-        auth: (answers.auth || "none"),
+        auth: answers.auth || "none",
         language: answers.language,
         packageManager: answers.packageManager,
     };
@@ -220,7 +222,7 @@ async function generateProject(config, targetDir, options) {
         copySpinner.fail("Failed to create project files");
         throw error;
     }
-    if (options?.install !== false && !(options?.['skip-install'] || options?.skipInstall)) {
+    if (options?.install !== false && !(options?.["skip-install"] || options?.skipInstall)) {
         const installSpinner = logger_1.logger.startSpinner("Installing dependencies...");
         try {
             await (0, package_manager_1.installDependencies)(targetDir, config.packageManager);
@@ -231,7 +233,9 @@ async function generateProject(config, targetDir, options) {
             throw error;
         }
     }
-    if (postInstallCommands.length > 0 && options?.install !== false && !(options?.['skip-install'] || options?.skipInstall)) {
+    if (postInstallCommands.length > 0 &&
+        options?.install !== false &&
+        !(options?.["skip-install"] || options?.skipInstall)) {
         const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
         try {
             for (const command of postInstallCommands) {
@@ -244,7 +248,7 @@ async function generateProject(config, targetDir, options) {
             throw error;
         }
     }
-    if (options?.git !== false && !(options?.['no-git'] || options?.noGit)) {
+    if (options?.git !== false && !(options?.["no-git"] || options?.noGit)) {
         const gitSpinner = logger_1.logger.startSpinner("Initializing git repository...");
         try {
             await (0, git_utils_1.initGit)(targetDir);
@@ -257,8 +261,8 @@ async function generateProject(config, targetDir, options) {
 }
 async function composeTemplate(config, targetDir) {
     const packageRoot = (0, package_root_1.getPackageRoot)();
-    const templatesDir = path_1.default.join(packageRoot, 'templates');
-    const modulesDirForGenerator = path_1.default.join(packageRoot, 'modules');
+    const templatesDir = path_1.default.join(packageRoot, "templates");
+    const modulesDirForGenerator = path_1.default.join(packageRoot, "modules");
     await fs_extra_1.default.ensureDir(targetDir);
     const frameworkConfig = await framework_utils_1.FrameworkUtils.loadFrameworkConfig(config.framework, templatesDir);
     const generator = new code_generator_1.AdvancedCodeGenerator(frameworkConfig);
@@ -266,8 +270,8 @@ async function composeTemplate(config, targetDir) {
     const features = [];
     const postInstallCommands = await generator.generate({
         framework: config.framework,
-        database: config.database === 'none' ? undefined : config.database,
-        auth: config.auth === 'none' ? undefined : config.auth,
+        database: config.database === "none" ? undefined : config.database,
+        auth: config.auth === "none" ? undefined : config.auth,
         prismaProvider: config.prismaProvider,
     }, features, targetDir);
     const packageJsonPath = path_1.default.join(targetDir, "package.json");
@@ -285,12 +289,75 @@ async function composeTemplate(config, targetDir) {
         }
     }
     catch {
+        // env copy failed.
     }
     if (config.language === "javascript") {
         await (0, js_conversion_1.convertToJavaScript)(targetDir, config.framework);
     }
     return postInstallCommands;
 }
+async function processGeneratorEnvVars(config, targetDir) {
+    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules");
+    const envVars = [];
+    // Process database generator env vars
+    if (config.database && config.database !== "none") {
+        const dbGeneratorPath = path_1.default.join(modulesDir, "database", config.database, "generator.json");
+        if (await fs_extra_1.default.pathExists(dbGeneratorPath)) {
+            const generator = await fs_extra_1.default.readJson(dbGeneratorPath);
+            if (generator.operations) {
+                for (const operation of generator.operations) {
+                    if (operation.type === "add-env" && (!operation.condition || checkCondition(operation.condition, config))) {
+                        for (const [key, value] of Object.entries(operation.envVars)) {
+                            envVars.push({
+                                key,
+                                value: value,
+                                required: true,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Process auth generator env vars
+    if (config.auth && config.auth !== "none") {
+        const authGeneratorPath = path_1.default.join(modulesDir, "auth", config.auth, "generator.json");
+        if (await fs_extra_1.default.pathExists(authGeneratorPath)) {
+            const generator = await fs_extra_1.default.readJson(authGeneratorPath);
+            if (generator.operations) {
+                for (const operation of generator.operations) {
+                    if (operation.type === "add-env" && (!operation.condition || checkCondition(operation.condition, config))) {
+                        for (const [key, value] of Object.entries(operation.envVars)) {
+                            envVars.push({
+                                key,
+                                value: value,
+                                required: true,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (envVars.length > 0) {
+        await (0, env_editor_1.addEnvVariables)(targetDir, envVars, { force: true });
+    }
+}
+function checkCondition(condition, config) {
+    for (const [key, value] of Object.entries(condition)) {
+        if (Array.isArray(value)) {
+            if (!value.includes(config[key])) {
+                return false;
+            }
+        }
+        else {
+            if (config[key] !== value) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 function showNextSteps(config) {
     logger_1.logger.newLine();
     logger_1.logger.success(`Created ${config.projectName}`);