stackkit 0.1.9 → 0.2.1

package/README.md

@@ -1,43 +1,34 @@
 # StackKit CLI
 
-Production-ready CLI for creating and enhancing JavaScript applications.
+CLI for scaffolding and composing modular JavaScript applications.
 
-## Installation
+## Quick Start
 
-```bash
-npm install -g stackkit
-# or
-npx stackkit
-```
-
-## Create New Project
+Create a new project without installing globally:
 
 ```bash
-npx stackkit create my-app
+npx stackkit@latest create my-app
 ```
 
-## Add Features to Existing Project
+Add features to an existing project:
 
 ```bash
-npx stackkit add
-# or non-interactive
-npx stackkit add auth
-npx stackkit add database
+npx stackkit@latest add <module>
 ```
 
-## Check Project Health
+Check project health:
 
 ```bash
-npx stackkit doctor
+npx stackkit@latest doctor
 ```
 
-## Supported Technologies
+## Supported technologies
 
-- **Frameworks**: Next.js, React, Express
-- **Databases**: Prisma (PostgreSQL, MongoDB, MySQL, SQLite), Mongoose (MongoDB)
-- **Auth**: Better Auth, Auth.js
+- Frameworks: Next.js, React, Express
+- Databases: Prisma, Mongoose
+- Auth: Auth.js / Better Auth
 
-## Documentation
+## Links
 
-- [StackKit Docs](https://stackkit.tariqul.dev)
-- [GitHub Repository](https://github.com/tariqul420/stackkit)
+- Website: https://stackkit.tariqul.dev
+- Repo: https://github.com/tariqul420/stackkit

package/dist/cli/add.js

@@ -9,14 +9,16 @@ const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const path_1 = __importDefault(require("path"));
-const code_generator_1 = require("../lib/generation/code-generator");
-const detect_1 = require("../lib/project/detect");
+const module_discovery_1 = require("../lib/discovery/module-discovery");
+const shared_1 = require("../lib/discovery/shared");
 const env_editor_1 = require("../lib/env/env-editor");
+const framework_utils_1 = require("../lib/framework/framework-utils");
 const files_1 = require("../lib/fs/files");
-const logger_1 = require("../lib/ui/logger");
+const code_generator_1 = require("../lib/generation/code-generator");
 const package_manager_1 = require("../lib/pm/package-manager");
+const detect_1 = require("../lib/project/detect");
+const logger_1 = require("../lib/ui/logger");
 const package_root_1 = require("../lib/utils/package-root");
-const framework_utils_1 = require("../lib/framework/framework-utils");
 async function addCommand(module, options) {
     try {
         const projectRoot = process.cwd();
@@ -39,30 +41,24 @@ async function addCommand(module, options) {
 }
 async function getAddConfig(module, options, projectInfo) {
     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") {
-                throw new Error("Provider is required for database. Use: `npx stackkit add database --provider <provider>`");
+                throw new Error("Provider is required for database. Use: `npx stackkit@latest add database --provider <provider>`");
             }
             else {
-                throw new Error("Provider is required for auth. Use: `npx stackkit add auth --provider <provider>`");
+                throw new Error("Provider is required for auth. Use: `npx stackkit@latest add auth --provider <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 parsed = (0, shared_1.parseDatabaseOption)(options.provider || "");
+            const baseProvider = parsed.database;
+            const adapterProvider = parsed.provider
+                ? `${parsed.database}-${parsed.provider}`
+                : parsed.database;
             const moduleMetadata = await loadModuleMetadata(modulesDir, baseProvider, baseProvider);
             if (!moduleMetadata) {
                 throw new Error(`Database provider "${baseProvider}" not found`);
@@ -70,7 +66,9 @@ async function getAddConfig(module, options, projectInfo) {
             return {
                 module: "database",
                 provider: adapterProvider,
-                displayName: `${moduleMetadata.displayName} (${adapterProvider.split("-")[1] || adapterProvider})`,
+                displayName: parsed.database === "prisma" && parsed.provider
+                    ? `${moduleMetadata.displayName} (${parsed.provider})`
+                    : moduleMetadata.displayName,
                 metadata: moduleMetadata,
             };
         }
@@ -104,59 +102,46 @@ async function getInteractiveConfig(modulesDir, projectInfo) {
         },
     ]);
     const category = answers.category;
+    const discovered = await (0, module_discovery_1.discoverModules)(modulesDir);
     if (category === "database") {
+        const dbChoices = (0, module_discovery_1.getDatabaseChoices)(discovered.databases || [], projectInfo?.framework || "nextjs");
         const dbAnswers = await inquirer_1.default.prompt([
             {
                 type: "list",
                 name: "database",
                 message: "Select database:",
-                choices: [
-                    { name: "Prisma", value: "prisma" },
-                    { name: "Mongoose", value: "mongoose" },
-                ],
+                choices: dbChoices,
             },
         ]);
         const selectedDb = dbAnswers.database;
-        if (selectedDb === "prisma") {
-            const providerAnswers = await inquirer_1.default.prompt([
-                {
-                    type: "list",
-                    name: "provider",
-                    message: "Select Prisma provider:",
-                    choices: [
-                        { name: "PostgreSQL", value: "postgresql" },
-                        { name: "MongoDB", value: "mongodb" },
-                        { name: "MySQL", value: "mysql" },
-                        { name: "SQLite", value: "sqlite" },
-                    ],
-                },
-            ]);
+        if (selectedDb.startsWith("prisma-")) {
+            const provider = selectedDb.split("-")[1];
             return {
                 module: "database",
-                provider: `prisma-${providerAnswers.provider}`,
-                displayName: `Prisma (${providerAnswers.provider})`,
+                provider: `prisma-${provider}`,
+                displayName: `Prisma (${provider})`,
                 metadata: (await loadModuleMetadata(modulesDir, "prisma", "prisma")),
             };
         }
-        else {
-            return {
-                module: "database",
-                provider: "mongoose",
-                displayName: "Mongoose",
-                metadata: (await loadModuleMetadata(modulesDir, "mongoose", "mongoose")),
-            };
-        }
+        // Other databases (mongoose, etc.)
+        const meta = (await loadModuleMetadata(modulesDir, selectedDb, selectedDb));
+        if (!meta)
+            throw new Error(`Database provider "${selectedDb}" not found`);
+        return {
+            module: "database",
+            provider: selectedDb,
+            displayName: meta.displayName || selectedDb,
+            metadata: meta,
+        };
     }
     else if (category === "auth") {
+        const authChoices = (discovered.auth || []).map((a) => ({ name: a.displayName, value: a.name }));
         const authAnswers = await inquirer_1.default.prompt([
             {
                 type: "list",
                 name: "auth",
                 message: "Select authentication:",
-                choices: [
-                    { name: "Better Auth", value: "better-auth" },
-                    { name: "Auth.js", value: "authjs" },
-                ],
+                choices: authChoices,
             },
         ]);
         const selectedAuth = authAnswers.auth;
@@ -164,67 +149,19 @@ async function getInteractiveConfig(modulesDir, projectInfo) {
         if (!metadata) {
             throw new Error(`Auth provider "${selectedAuth}" not found`);
         }
-        if (projectInfo && !metadata.supportedFrameworks.includes(projectInfo.framework)) {
+        if (projectInfo && metadata.supportedFrameworks && !metadata.supportedFrameworks.includes(projectInfo.framework)) {
             throw new Error(`Auth provider "${selectedAuth}" does not support ${projectInfo.framework}`);
         }
         return {
             module: "auth",
             provider: selectedAuth,
-            displayName: selectedAuth === "better-auth" ? "Better Auth" : "Auth.js",
+            displayName: metadata.displayName || selectedAuth,
             metadata,
         };
     }
     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`);
-}
+/* removed unused getProviderConfig — discovery-based flows handle providers */
 async function addModuleToProject(projectRoot, projectInfo, config, options) {
     const moduleMetadata = config.metadata;
     const selectedProvider = config.provider;
@@ -297,12 +234,10 @@ 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];
-            }
-            else {
-                selectedModules.database = config.provider;
+            const parsed = (0, shared_1.parseDatabaseOption)(config.provider);
+            selectedModules.database = parsed.database;
+            if (parsed.database === "prisma" && parsed.provider) {
+                selectedModules.prismaProvider = parsed.provider;
             }
         }
         if (config.module === "auth" && config.provider) {

package/dist/cli/create.js

@@ -10,15 +10,16 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const path_1 = __importDefault(require("path"));
 const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
-const git_utils_1 = require("../lib/git-utils");
 const js_conversion_1 = require("../lib/conversion/js-conversion");
-const package_manager_1 = require("../lib/pm/package-manager");
-const logger_1 = require("../lib/ui/logger");
-const framework_utils_1 = require("../lib/framework/framework-utils");
 const module_discovery_1 = require("../lib/discovery/module-discovery");
+const shared_1 = require("../lib/discovery/shared");
+const env_editor_1 = require("../lib/env/env-editor");
+const framework_utils_1 = require("../lib/framework/framework-utils");
 const code_generator_1 = require("../lib/generation/code-generator");
+const git_utils_1 = require("../lib/git-utils");
+const package_manager_1 = require("../lib/pm/package-manager");
+const logger_1 = require("../lib/ui/logger");
 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"));
@@ -91,7 +92,7 @@ async function getProjectConfig(projectName, options) {
         let database = "none";
         let prismaProvider;
         if (db && db !== "none") {
-            const parsed = (0, module_discovery_1.parseDatabaseOption)(db);
+            const parsed = (0, shared_1.parseDatabaseOption)(db);
             database = parsed.database;
             prismaProvider = parsed.provider;
         }
@@ -151,12 +152,16 @@ async function getProjectConfig(projectName, options) {
             name: "database",
             message: "Select database/ORM:",
             when: (answers) => answers.framework !== "react",
-            choices: [
-                { name: "Prisma", value: "prisma" },
-                { name: "Mongoose", value: "mongoose" },
-                { name: "None", value: "none" },
-            ],
+            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" },
+                ],
         },
+        // 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",
@@ -199,13 +204,21 @@ 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-")) {
+        const parts = databaseAnswer.split("-");
+        if (parts.length >= 2) {
+            prismaProviderAnswer = parts[1];
+            databaseAnswer = "prisma";
+        }
+    }
     return {
         projectName: (projectName || answers.projectName),
         framework: answers.framework,
-        database: (answers.framework === "react"
-            ? "none"
-            : answers.database),
-        prismaProvider: answers.prismaProvider,
+        database: databaseAnswer,
+        prismaProvider: prismaProviderAnswer,
         auth: answers.auth || "none",
         language: answers.language,
         packageManager: answers.packageManager,

package/dist/cli/doctor.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("../lib/ui/logger");
+const package_root_1 = require("../lib/utils/package-root");
 // Constants for consistent messaging
 const MESSAGES = {
     NO_PACKAGE_JSON: "No package.json found in current directory or any parent directory.",
@@ -211,24 +212,125 @@ function checkNodeVersion() {
 function detectAuthModules(packageJson) {
     const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
     const modules = [];
-    if (deps["better-auth"]) {
-        modules.push("better-auth");
+    try {
+        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "auth");
+        if (fs_extra_1.default.existsSync(modulesDir)) {
+            const authDirs = fs_extra_1.default.readdirSync(modulesDir);
+            for (const authDir of authDirs) {
+                try {
+                    const genPath = path_1.default.join(modulesDir, authDir, "generator.json");
+                    const modJson = path_1.default.join(modulesDir, authDir, "module.json");
+                    let pkgNames = [];
+                    if (fs_extra_1.default.existsSync(genPath)) {
+                        const gen = JSON.parse(fs_extra_1.default.readFileSync(genPath, "utf-8"));
+                        if (Array.isArray(gen.operations)) {
+                            for (const op of gen.operations) {
+                                if (op.dependencies && typeof op.dependencies === "object") {
+                                    pkgNames.push(...Object.keys(op.dependencies));
+                                }
+                                if (op.devDependencies && typeof op.devDependencies === "object") {
+                                    pkgNames.push(...Object.keys(op.devDependencies));
+                                }
+                            }
+                        }
+                    }
+                    // Fallback: check module.json provider/name
+                    let moduleName = authDir;
+                    if (fs_extra_1.default.existsSync(modJson)) {
+                        try {
+                            const m = JSON.parse(fs_extra_1.default.readFileSync(modJson, "utf-8"));
+                            if (m && m.name)
+                                moduleName = m.name;
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                    for (const pkg of pkgNames) {
+                        if (deps[pkg]) {
+                            modules.push(moduleName);
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // ignore per-module errors
+                }
+            }
+        }
     }
-    if (deps["next-auth"]) {
-        modules.push("authjs");
+    catch {
+        // ignore discovery errors
     }
-    return modules;
+    // Fallback to original simple checks if nothing found
+    if (modules.length === 0) {
+        if (deps["better-auth"])
+            modules.push("better-auth");
+        if (deps["next-auth"])
+            modules.push("authjs");
+    }
+    return Array.from(new Set(modules));
 }
 function detectDatabaseModules(packageJson) {
     const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
     const modules = [];
-    if (deps["@prisma/client"] || deps["prisma"]) {
-        modules.push("prisma");
+    try {
+        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "database");
+        if (fs_extra_1.default.existsSync(modulesDir)) {
+            const dbDirs = fs_extra_1.default.readdirSync(modulesDir);
+            for (const dbDir of dbDirs) {
+                try {
+                    const genPath = path_1.default.join(modulesDir, dbDir, "generator.json");
+                    const modJson = path_1.default.join(modulesDir, dbDir, "module.json");
+                    let pkgNames = [];
+                    if (fs_extra_1.default.existsSync(genPath)) {
+                        const gen = JSON.parse(fs_extra_1.default.readFileSync(genPath, "utf-8"));
+                        if (Array.isArray(gen.operations)) {
+                            for (const op of gen.operations) {
+                                if (op.dependencies && typeof op.dependencies === "object") {
+                                    pkgNames.push(...Object.keys(op.dependencies));
+                                }
+                                if (op.devDependencies && typeof op.devDependencies === "object") {
+                                    pkgNames.push(...Object.keys(op.devDependencies));
+                                }
+                            }
+                        }
+                    }
+                    let moduleName = dbDir;
+                    if (fs_extra_1.default.existsSync(modJson)) {
+                        try {
+                            const m = JSON.parse(fs_extra_1.default.readFileSync(modJson, "utf-8"));
+                            if (m && m.name)
+                                moduleName = m.name;
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                    for (const pkg of pkgNames) {
+                        if (deps[pkg]) {
+                            modules.push(moduleName);
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // ignore per-module errors
+                }
+            }
+        }
+    }
+    catch {
+        // ignore discovery errors
     }
-    if (deps["mongoose"]) {
-        modules.push("mongoose");
+    // Fallback to original checks if nothing found
+    if (modules.length === 0) {
+        if (deps["@prisma/client"] || deps["prisma"])
+            modules.push("prisma");
+        if (deps["mongoose"])
+            modules.push("mongoose");
     }
-    return modules;
+    return Array.from(new Set(modules));
 }
 async function checkKeyFiles(projectRoot, projectType, authModules, databaseModules) {
     const checks = [];
@@ -260,8 +362,42 @@ async function checkKeyFiles(projectRoot, projectType, authModules, databaseModu
 async function checkAuthRoutesExist(projectRoot, projectType) {
     if (projectType !== "nextjs")
         return true; // Skip for non-Next.js
-    const possiblePaths = [
-        // NextAuth routes
+    // Build candidate auth route paths from generator.json files in modules/auth
+    const candidates = new Set();
+    try {
+        const authModulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "auth");
+        if (await fs_extra_1.default.pathExists(authModulesDir)) {
+            const authDirs = await fs_extra_1.default.readdir(authModulesDir);
+            for (const dir of authDirs) {
+                const genPath = path_1.default.join(authModulesDir, dir, "generator.json");
+                if (!(await fs_extra_1.default.pathExists(genPath)))
+                    continue;
+                try {
+                    const gen = await fs_extra_1.default.readJson(genPath);
+                    if (Array.isArray(gen.operations)) {
+                        for (const op of gen.operations) {
+                            if (typeof op.destination === "string")
+                                candidates.add(op.destination);
+                            if (Array.isArray(op.operations)) {
+                                for (const sub of op.operations) {
+                                    if (typeof sub.destination === "string")
+                                        candidates.add(sub.destination);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // ignore malformed generator
+                }
+            }
+        }
+    }
+    catch {
+        // ignore discovery errors
+    }
+    // Fallback to known common paths if generators don't provide any
+    const fallback = [
         "app/api/auth/[...nextauth]/route.ts",
         "app/api/auth/[...nextauth]/route.js",
         "src/app/api/auth/[...nextauth]/route.ts",
@@ -270,13 +406,14 @@ async function checkAuthRoutesExist(projectRoot, projectType) {
         "pages/api/auth/[...nextauth].js",
         "src/pages/api/auth/[...nextauth].ts",
         "src/pages/api/auth/[...nextauth].js",
-        // Better Auth routes
         "app/api/auth/[...all]/route.ts",
         "app/api/auth/[...all]/route.js",
         "src/app/api/auth/[...all]/route.ts",
         "src/app/api/auth/[...all]/route.js",
     ];
-    for (const routePath of possiblePaths) {
+    for (const p of fallback)
+        candidates.add(p);
+    for (const routePath of candidates) {
         if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, routePath))) {
             return true;
         }
@@ -288,14 +425,59 @@ async function checkEnvFiles(projectRoot, authModules, databaseModules) {
     const requiredKeys = [];
     const missing = [];
     const present = [];
-    if (databaseModules.includes("prisma")) {
-        requiredKeys.push("DATABASE_URL");
-    }
-    if (authModules.includes("authjs")) {
-        requiredKeys.push("NEXTAUTH_SECRET", "NEXTAUTH_URL");
+    // Dynamically collect required env keys from generator.json for detected modules
+    try {
+        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules");
+        async function collectEnvKeys(category, name) {
+            const genPath = path_1.default.join(modulesDir, category, name, "generator.json");
+            if (!(await fs_extra_1.default.pathExists(genPath)))
+                return;
+            try {
+                const gen = await fs_extra_1.default.readJson(genPath);
+                if (Array.isArray(gen.operations)) {
+                    for (const op of gen.operations) {
+                        if (op.type === "add-env" && op.envVars && typeof op.envVars === "object") {
+                            for (const k of Object.keys(op.envVars)) {
+                                if (!requiredKeys.includes(k))
+                                    requiredKeys.push(k);
+                            }
+                        }
+                        // Also check nested operations (e.g., patch-file -> operations)
+                        if (Array.isArray(op.operations)) {
+                            for (const sub of op.operations) {
+                                if (sub.type === "add-env" && sub.envVars && typeof sub.envVars === "object") {
+                                    for (const k of Object.keys(sub.envVars)) {
+                                        if (!requiredKeys.includes(k))
+                                            requiredKeys.push(k);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // ignore malformed generator
+            }
+        }
+        for (const db of databaseModules) {
+            await collectEnvKeys("database", db);
+        }
+        for (const auth of authModules) {
+            await collectEnvKeys("auth", auth);
+        }
     }
-    if (authModules.includes("better-auth")) {
-        requiredKeys.push("BETTER_AUTH_SECRET", "BETTER_AUTH_URL");
+    catch {
+        // fallback to previous minimal checks if discovery fails
+        if (databaseModules.includes("prisma")) {
+            requiredKeys.push("DATABASE_URL");
+        }
+        if (authModules.includes("authjs")) {
+            requiredKeys.push("NEXTAUTH_SECRET", "NEXTAUTH_URL");
+        }
+        if (authModules.includes("better-auth")) {
+            requiredKeys.push("BETTER_AUTH_SECRET", "BETTER_AUTH_URL");
+        }
     }
     const envPaths = [".env", ".env.local"];
     let envContent = "";