stackkit 0.2.2 → 0.2.6

package/bin/stackkit.js

@@ -1,4 +1,11 @@
 #!/usr/bin/env node
-
-// eslint-disable-next-line
-require("../dist/index.js");
+/* eslint-disable */
+try {
+  require("../dist/index.js");
+} catch (err) {
+  console.error(
+    "Failed to load compiled CLI (did you run 'npm run build'?)",
+    err && err.message ? err.message : err,
+  );
+  process.exitCode = 1;
+}

package/dist/cli/add.js

@@ -26,9 +26,17 @@ async function addCommand(module, options) {
         const projectInfo = await (0, detect_1.detectProjectInfo)(projectRoot);
         spinner.succeed(`Detected ${projectInfo.framework} (${projectInfo.router} router, ${projectInfo.language})`);
         const config = await getAddConfig(module, options, projectInfo);
-        await addModuleToProject(projectRoot, projectInfo, config, options);
+        // Refresh project detection in case getAddConfig performed a pre-add (database)
+        const refreshedProjectInfo = await (0, detect_1.detectProjectInfo)(projectRoot);
+        await addModuleToProject(projectRoot, refreshedProjectInfo, config, options);
         logger_1.logger.newLine();
-        logger_1.logger.success(`Added ${chalk_1.default.bold(config.displayName)}`);
+        if (config.preAdded && config.preAdded.length > 0) {
+            const addedNames = [...config.preAdded.map((p) => p.displayName), config.displayName].map((s) => chalk_1.default.bold(s));
+            logger_1.logger.success(`Added ${addedNames.join(" and ")}`);
+        }
+        else {
+            logger_1.logger.success(`Added ${chalk_1.default.bold(config.displayName)}`);
+        }
         logger_1.logger.newLine();
     }
     catch (error) {
@@ -42,7 +50,7 @@ async function addCommand(module, options) {
 async function getAddConfig(module, options, projectInfo) {
     const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules");
     if (!module) {
-        return await getInteractiveConfig(modulesDir, projectInfo);
+        return await getInteractiveConfig(modulesDir, projectInfo, options);
     }
     if (module === "database" || module === "auth") {
         if (!options?.provider) {
@@ -67,8 +75,8 @@ async function getAddConfig(module, options, projectInfo) {
                 module: "database",
                 provider: adapterProvider,
                 displayName: parsed.database === "prisma" && parsed.provider
-                    ? `${moduleMetadata.displayName} (${parsed.provider})`
-                    : moduleMetadata.displayName,
+                    ? `${moduleMetadata.displayName || baseProvider} (${parsed.provider})`
+                    : moduleMetadata.displayName || baseProvider,
                 metadata: moduleMetadata,
             };
         }
@@ -78,24 +86,26 @@ async function getAddConfig(module, options, projectInfo) {
             if (!moduleMetadata) {
                 throw new Error(`Auth provider "${provider}" not found`);
             }
-            // Validate compatibility with existing project
             if (projectInfo) {
-                // Auth.js requires Next.js + Prisma
-                if (provider === "authjs" &&
-                    (projectInfo.framework !== "nextjs" || !projectInfo.hasPrisma)) {
-                    throw new Error("Auth.js is only supported with Next.js and Prisma database in this project");
+                if (moduleMetadata.supportedFrameworks &&
+                    !moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
+                    throw new Error(`${moduleMetadata.displayName} is not supported on ${projectInfo.framework}`);
                 }
-                // Better-auth requires a database for server frameworks (non-react)
-                if (provider === "better-auth" &&
-                    !projectInfo.hasDatabase &&
-                    projectInfo.framework !== "react") {
-                    throw new Error("Better Auth requires a database for server frameworks in this project");
+                const dbName = projectInfo.hasPrisma
+                    ? "prisma"
+                    : projectInfo.hasDatabase
+                        ? "other"
+                        : "none";
+                if (moduleMetadata.compatibility &&
+                    moduleMetadata.compatibility.databases &&
+                    !moduleMetadata.compatibility.databases.includes(dbName)) {
+                    throw new Error(`${moduleMetadata.displayName} is not compatible with the project's database configuration`);
                 }
             }
             return {
                 module: "auth",
                 provider,
-                displayName: moduleMetadata.displayName,
+                displayName: moduleMetadata.displayName || provider,
                 metadata: moduleMetadata,
             };
         }
@@ -103,15 +113,17 @@ async function getAddConfig(module, options, projectInfo) {
     // Unknown module type
     throw new Error(`Unknown module type "${module}". Use "database" or "auth", or specify a provider directly.`);
 }
-async function getInteractiveConfig(modulesDir, projectInfo) {
-    // Discover modules once and use compatibility info to decide which categories to show
+async function getInteractiveConfig(modulesDir, projectInfo, options) {
+    const projectRoot = process.cwd();
     const discovered = await (0, module_discovery_1.discoverModules)(modulesDir);
-    const compatibleAuths = (0, module_discovery_1.getCompatibleAuthOptions)(discovered.auth || [], projectInfo?.framework || "nextjs", projectInfo?.hasPrisma ? "prisma" : "none");
+    // Prefer discovered framework, then projectInfo.framework; leave empty if unknown
+    const defaultFramework = (discovered.frameworks && discovered.frameworks[0]?.name) || projectInfo?.framework || "";
+    const compatibleAuths = (0, module_discovery_1.getCompatibleAuthOptions)(discovered.auth || [], projectInfo?.framework || defaultFramework, projectInfo?.hasPrisma ? "prisma" : "none", discovered.frameworks);
     const categories = [
         { name: "Database", value: "database" },
     ];
-    // Only show Auth category if there is at least one compatible auth option
-    if (compatibleAuths.length > 1) {
+    // Offer Auth category when there's at least one compatible auth option
+    if (compatibleAuths.length > 0) {
         categories.push({ name: "Auth", value: "auth" });
     }
     const answers = await inquirer_1.default.prompt([
@@ -124,7 +136,7 @@ async function getInteractiveConfig(modulesDir, projectInfo) {
     ]);
     const category = answers.category;
     if (category === "database") {
-        const dbChoices = (0, module_discovery_1.getDatabaseChoices)(discovered.databases || [], projectInfo?.framework || "nextjs");
+        const dbChoices = (0, module_discovery_1.getDatabaseChoices)(discovered.databases || [], projectInfo?.framework || defaultFramework);
         const dbAnswers = await inquirer_1.default.prompt([
             {
                 type: "list",
@@ -155,9 +167,51 @@ async function getInteractiveConfig(modulesDir, projectInfo) {
         };
     }
     else if (category === "auth") {
-        // Filter auth choices based on project compatibility (framework + database)
+        let preAddedForReturn;
+        if (!projectInfo?.hasDatabase) {
+            logger_1.logger.warn("No database detected in the project. Authentication requires a database.");
+            const dbChoices = (0, module_discovery_1.getDatabaseChoices)(discovered.databases || [], projectInfo?.framework || defaultFramework);
+            const dbAnswer = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "database",
+                    message: "Select a database to add before authentication:",
+                    choices: dbChoices,
+                },
+            ]);
+            const selectedDb = dbAnswer.database;
+            if (!selectedDb || selectedDb === "none") {
+                logger_1.logger.info("Cancelled — authentication requires a database");
+                process.exit(0);
+            }
+            let dbConfig;
+            if (selectedDb.startsWith("prisma-")) {
+                const provider = selectedDb.split("-")[1];
+                dbConfig = {
+                    module: "database",
+                    provider: `prisma-${provider}`,
+                    displayName: `Prisma (${provider})`,
+                    metadata: (await loadModuleMetadata(modulesDir, "prisma", "prisma")),
+                };
+            }
+            else {
+                const meta = (await loadModuleMetadata(modulesDir, selectedDb, selectedDb));
+                if (!meta)
+                    throw new Error(`Database provider "${selectedDb}" not found`);
+                dbConfig = {
+                    module: "database",
+                    provider: selectedDb,
+                    displayName: meta.displayName || selectedDb,
+                    metadata: meta,
+                };
+            }
+            await addModuleToProject(projectRoot, projectInfo || (await (0, detect_1.detectProjectInfo)(projectRoot)), dbConfig, options);
+            projectInfo = await (0, detect_1.detectProjectInfo)(projectRoot);
+            dbConfig.preAdded = dbConfig.preAdded || [];
+            preAddedForReturn = dbConfig;
+        }
         const dbString = projectInfo?.hasPrisma ? "prisma" : "none";
-        const authChoices = (0, module_discovery_1.getCompatibleAuthOptions)(discovered.auth || [], projectInfo?.framework || "nextjs", dbString);
+        const authChoices = (0, module_discovery_1.getCompatibleAuthOptions)(discovered.auth || [], projectInfo?.framework || defaultFramework, dbString);
         const authAnswers = await inquirer_1.default.prompt([
             {
                 type: "list",
@@ -180,16 +234,19 @@ async function getInteractiveConfig(modulesDir, projectInfo) {
             !metadata.supportedFrameworks.includes(projectInfo.framework)) {
             throw new Error(`Auth provider "${selectedAuth}" does not support ${projectInfo.framework}`);
         }
-        return {
+        const result = {
             module: "auth",
             provider: selectedAuth,
             displayName: metadata.displayName || selectedAuth,
             metadata,
         };
+        if (typeof preAddedForReturn !== "undefined" && preAddedForReturn) {
+            result.preAdded = [preAddedForReturn];
+        }
+        return result;
     }
     throw new Error("Invalid selection");
 }
-/* removed unused getProviderConfig — discovery-based flows handle providers */
 async function addModuleToProject(projectRoot, projectInfo, config, options) {
     const moduleMetadata = config.metadata;
     const selectedProvider = config.provider;
@@ -261,6 +318,29 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
             }
         }
         const selectedModules = { framework: projectInfo.framework };
+        try {
+            const pkg = await fs_extra_1.default.readJson(path_1.default.join(projectRoot, "package.json"));
+            const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+            if (projectInfo.hasPrisma) {
+                selectedModules.database = "prisma";
+                const prismaSchema = path_1.default.join(projectRoot, "prisma", "schema.prisma");
+                if (await fs_extra_1.default.pathExists(prismaSchema)) {
+                    const content = await fs_extra_1.default.readFile(prismaSchema, "utf-8");
+                    const dsMatch = content.match(/datasource\s+\w+\s*\{([\s\S]*?)\}/i);
+                    if (dsMatch && dsMatch[1]) {
+                        const provMatch = dsMatch[1].match(/provider\s*=\s*["']([^"']+)["']/i);
+                        if (provMatch && provMatch[1])
+                            selectedModules.prismaProvider = provMatch[1];
+                    }
+                }
+            }
+            else if (deps["mongoose"]) {
+                selectedModules.database = "mongoose";
+            }
+        }
+        catch {
+            // ignore detection errors
+        }
         if (config.module === "database" && config.provider) {
             const parsed = (0, shared_1.parseDatabaseOption)(config.provider);
             selectedModules.database = parsed.database;
@@ -272,7 +352,6 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
             selectedModules.auth = config.provider;
         }
         const postInstall = await gen.applyToProject(selectedModules, [], projectRoot);
-        // Install dependencies first, then run post-install commands (e.g. prisma generate)
         if (!options?.dryRun && options?.install !== false) {
             const installSpinner = logger_1.logger.startSpinner("Installing dependencies...");
             try {
@@ -285,30 +364,39 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
             }
         }
         if (postInstall && postInstall.length > 0 && !options?.dryRun) {
-            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" });
-                }
-                postInstallSpinner.succeed("Post-install commands completed");
+            const createdFiles = gen.getCreatedFiles ? gen.getCreatedFiles() : [];
+            if (createdFiles.length === 0) {
+                logger_1.logger.warn("Skipping post-install commands — no files were created by generators to act upon.");
             }
-            catch (error) {
-                postInstallSpinner.fail("Failed to run post-install commands");
-                throw error;
+            else {
+                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" });
+                    }
+                    postInstallSpinner.succeed("Post-install commands completed");
+                }
+                catch (error) {
+                    postInstallSpinner.fail("Failed to run post-install commands");
+                    throw error;
+                }
             }
         }
         return;
     }
     const mergedDeps = {};
     const mergedDevDeps = {};
-    if (moduleMetadata.frameworkConfigs?.shared?.dependencies) {
-        Object.assign(mergedDeps, moduleMetadata.frameworkConfigs.shared.dependencies);
+    try {
+        const shared = moduleMetadata.frameworkConfigs
+            ?.shared;
+        if (shared && shared.dependencies)
+            Object.assign(mergedDeps, shared.dependencies);
+        if (shared && shared.devDependencies)
+            Object.assign(mergedDevDeps, shared.devDependencies);
     }
-    if (moduleMetadata.frameworkConfigs?.shared?.devDependencies) {
-        Object.assign(mergedDevDeps, moduleMetadata.frameworkConfigs.shared.devDependencies);
+    catch {
+        // ignore malformed frameworkConfigs
     }
-    // Adapter-specific dependencies are applied via generator metadata; frameworkConfigs still merge above.
-    // Do not mutate the loaded module metadata here; use mergedDeps/mergedDevDeps for installation.
     const variables = {};
     if (selectedProvider) {
         variables.provider = selectedProvider;
@@ -344,16 +432,34 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
         await applyFrameworkPatches(projectRoot, moduleMetadata.frameworkPatches, projectInfo.framework);
     }
     if (moduleMetadata.postInstall && moduleMetadata.postInstall.length > 0 && !options?.dryRun) {
-        const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
-        try {
-            for (const command of moduleMetadata.postInstall) {
-                (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: "pipe" });
+        const createdFiles = [];
+        if (Array.isArray(moduleMetadata.patches)) {
+            for (const p of moduleMetadata.patches) {
+                if (p.type === "create-file") {
+                    const destPath = p.destination;
+                    if (typeof destPath === "string") {
+                        const dest = path_1.default.join(projectRoot, destPath);
+                        if (await fs_extra_1.default.pathExists(dest))
+                            createdFiles.push(destPath);
+                    }
+                }
             }
-            postInstallSpinner.succeed("Post-install commands completed");
         }
-        catch (error) {
-            postInstallSpinner.fail("Failed to run post-install commands");
-            throw error;
+        if (createdFiles.length === 0) {
+            logger_1.logger.warn("Skipping module post-install commands — no files were created by module patches to act upon.");
+        }
+        else {
+            const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
+            try {
+                for (const command of moduleMetadata.postInstall) {
+                    (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: "pipe" });
+                }
+                postInstallSpinner.succeed("Post-install commands completed");
+            }
+            catch (error) {
+                postInstallSpinner.fail("Failed to run post-install commands");
+                throw error;
+            }
         }
     }
     if (Object.keys(mergedDeps).length > 0 && options?.install !== false) {
@@ -374,16 +480,34 @@ async function addModuleToProject(projectRoot, projectInfo, config, options) {
             logger_1.logger.info(`Would add dev dependencies: ${devDeps.join(", ")}`);
         }
     }
-    if (moduleMetadata.envVars && moduleMetadata.envVars.length > 0) {
-        const processedEnvVars = moduleMetadata.envVars.map((envVar) => ({
-            ...envVar,
-            value: envVar.value?.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match),
-        }));
-        if (!options?.dryRun) {
-            await (0, env_editor_1.addEnvVariables)(projectRoot, processedEnvVars, { force: options?.force });
+    if (moduleMetadata.envVars) {
+        let envArray = [];
+        if (Array.isArray(moduleMetadata.envVars)) {
+            envArray = moduleMetadata.envVars;
         }
-        else {
-            logger_1.logger.log(`  ${chalk_1.default.dim("~")} .env.example`);
+        else if (typeof moduleMetadata.envVars === "object") {
+            envArray = Object.entries(moduleMetadata.envVars).map(([k, v]) => ({
+                key: k,
+                value: String(v),
+            }));
+        }
+        if (envArray.length > 0) {
+            const processedEnvVars = envArray.map((envVar) => ({
+                key: envVar.key || "",
+                value: envVar.value?.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match),
+                required: false,
+            }));
+            if (!options?.dryRun) {
+                const envVarsToAdd = processedEnvVars.map((e) => ({
+                    key: e.key,
+                    value: e.value,
+                    required: !!e.required,
+                }));
+                await (0, env_editor_1.addEnvVariables)(projectRoot, envVarsToAdd, { force: options?.force });
+            }
+            else {
+                logger_1.logger.log(`  ${chalk_1.default.dim("~")} .env.example`);
+            }
         }
     }
 }
@@ -475,8 +599,11 @@ async function findModulePath(modulesDir, moduleName, provider) {
             const metadataPath = path_1.default.join(modulePath, "module.json");
             if (await fs_extra_1.default.pathExists(metadataPath)) {
                 const metadata = await fs_extra_1.default.readJSON(metadataPath);
-                if (provider && moduleDir === provider) {
-                    return modulePath;
+                if (provider) {
+                    const baseProvider = String(provider).split("-")[0];
+                    if (moduleDir === provider || moduleDir === baseProvider) {
+                        return modulePath;
+                    }
                 }
                 if (!provider && metadata.name === moduleName) {
                     return modulePath;

package/dist/cli/create.js

@@ -45,12 +45,23 @@ async function getProjectConfig(projectName, options) {
     const optionsProvided = flagsProvided || !!(options && (options.yes || options.y));
     if (optionsProvided) {
         if (options && (options.yes || options.y) && !flagsProvided) {
+            const defaultFramework = discoveredModules.frameworks && discoveredModules.frameworks.length > 0
+                ? discoveredModules.frameworks[0].name
+                : "";
+            const defaultDatabase = discoveredModules.databases && discoveredModules.databases.length > 0
+                ? discoveredModules.databases[0].name
+                : "none";
+            const prismaProviders = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
+            const defaultPrismaProvider = prismaProviders.length > 0 ? prismaProviders[0] : undefined;
+            const defaultAuth = discoveredModules.auth && discoveredModules.auth.length > 0
+                ? discoveredModules.auth[0].name
+                : "none";
             return {
                 projectName: projectName || "my-app",
-                framework: "nextjs",
-                database: "prisma",
-                prismaProvider: "postgresql",
-                auth: "better-auth",
+                framework: defaultFramework,
+                database: defaultDatabase,
+                prismaProvider: defaultPrismaProvider,
+                auth: defaultAuth,
                 language: "typescript",
                 packageManager: "pnpm",
             };
@@ -100,12 +111,22 @@ async function getProjectConfig(projectName, options) {
         if (authOpt && authOpt !== "none") {
             auth = authOpt;
         }
-        const finalFramework = (framework || "nextjs");
-        if (auth === "authjs" && (database !== "prisma" || finalFramework !== "nextjs")) {
-            throw new Error("Auth.js is only supported with Next.js and Prisma database");
-        }
-        if (auth === "better-auth" && database === "none" && finalFramework !== "react") {
-            throw new Error("Better Auth requires a database for server frameworks");
+        const finalFramework = (framework || (discoveredModules.frameworks[0]?.name ?? ""));
+        // Validate auth compatibility using discovered module metadata when available
+        if (auth && auth !== "none" && discoveredModules.auth) {
+            const authMeta = discoveredModules.auth.find((a) => a.name === auth);
+            if (authMeta) {
+                if (authMeta.supportedFrameworks &&
+                    !authMeta.supportedFrameworks.includes(finalFramework)) {
+                    throw new Error(`${authMeta.displayName || auth} is not supported on ${finalFramework}`);
+                }
+                const dbName = database === "prisma" ? "prisma" : database === "none" ? "none" : "other";
+                if (authMeta.compatibility &&
+                    authMeta.compatibility.databases &&
+                    !authMeta.compatibility.databases.includes(dbName)) {
+                    throw new Error(`${authMeta.displayName || auth} is not compatible with the selected database configuration`);
+                }
+            }
         }
         return {
             projectName: projectName || "my-app",
@@ -117,6 +138,7 @@ async function getProjectConfig(projectName, options) {
             packageManager: (pm || "pnpm"),
         };
     }
+    const prismaProviders = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
     const answers = (await inquirer_1.default.prompt([
         {
             type: "input",
@@ -139,47 +161,66 @@ 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 }))
-                : [
-                    { name: "Next.js", value: "nextjs" },
-                    { name: "Express.js", value: "express" },
-                    { name: "React (Vite)", value: "react" },
-                ],
+            choices: (() => {
+                if (discoveredModules.frameworks && discoveredModules.frameworks.length > 0) {
+                    return discoveredModules.frameworks.map((f) => ({ name: f.displayName, value: f.name }));
+                }
+                // Fallback: read templates dir directly
+                try {
+                    const templatesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "templates");
+                    if (fs_extra_1.default.existsSync(templatesDir)) {
+                        const dirs = fs_extra_1.default.readdirSync(templatesDir).filter((d) => d !== "node_modules");
+                        return dirs.map((d) => ({ name: d.charAt(0).toUpperCase() + d.slice(1), value: d }));
+                    }
+                }
+                catch {
+                    // ignore
+                }
+                return [];
+            })(),
         },
         {
             type: "list",
             name: "database",
             message: "Select database/ORM:",
             when: (answers) => answers.framework !== "react",
-            choices: (answers) => discoveredModules.databases && discoveredModules.databases.length > 0
-                ? (0, module_discovery_1.getDatabaseChoices)(discoveredModules.databases, answers.framework)
-                : [
-                    { name: "Prisma", value: "prisma" },
-                    { name: "Mongoose", value: "mongoose" },
-                    { name: "None", value: "none" },
-                ],
+            choices: (answers) => {
+                if (discoveredModules.databases && discoveredModules.databases.length > 0) {
+                    return (0, module_discovery_1.getDatabaseChoices)(discoveredModules.databases, answers.framework);
+                }
+                // Fallback: scan modules/database directory
+                try {
+                    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "database");
+                    if (fs_extra_1.default.existsSync(modulesDir)) {
+                        const dbs = fs_extra_1.default
+                            .readdirSync(modulesDir)
+                            .map((d) => ({ name: d.charAt(0).toUpperCase() + d.slice(1), value: d }));
+                        dbs.push({ name: "None", value: "none" });
+                        return dbs;
+                    }
+                }
+                catch {
+                    // ignore
+                }
+                return [{ name: "None", value: "none" }];
+            },
         },
-        // If a prisma-* choice is selected above, `prismaProvider` will be derived from it,
-        // otherwise prompt for provider when `prisma` is selected directly.
         {
             type: "list",
             name: "prismaProvider",
             message: "Select database provider for Prisma:",
-            when: (answers) => answers.database === "prisma",
-            choices: [
-                { name: "PostgreSQL", value: "postgresql" },
-                { name: "MongoDB", value: "mongodb" },
-                { name: "MySQL", value: "mysql" },
-                { name: "SQLite", value: "sqlite" },
-            ],
+            when: (answers) => answers.database === "prisma" && prismaProviders.length > 0,
+            choices: prismaProviders.map((p) => ({
+                name: p.charAt(0).toUpperCase() + p.slice(1),
+                value: p,
+            })),
         },
         {
             type: "list",
             name: "auth",
             message: "Select authentication:",
             when: (answers) => answers.database !== "none" || answers.framework === "react",
-            choices: (answers) => (0, module_discovery_1.getCompatibleAuthOptions)(discoveredModules.auth, answers.framework, answers.database || "none"),
+            choices: (answers) => (0, module_discovery_1.getCompatibleAuthOptions)(discoveredModules.auth, answers.framework, answers.database || "none", discoveredModules.frameworks),
         },
         {
             type: "list",
@@ -204,7 +245,6 @@ async function getProjectConfig(projectName, options) {
             default: "pnpm",
         },
     ]));
-    // Normalize database answer (interactive flow): handle values like `prisma-postgresql`
     let databaseAnswer = answers.framework === "react" ? "none" : answers.database;
     let prismaProviderAnswer = answers.prismaProvider;
     if (typeof databaseAnswer === "string" && databaseAnswer.startsWith("prisma-")) {