create-stackkit-app 0.4.3 → 0.4.5

package/dist/lib/create-project.js

@@ -8,27 +8,112 @@ const chalk_1 = __importDefault(require("chalk"));
 const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
-const ora_1 = __importDefault(require("ora"));
 const path_1 = __importDefault(require("path"));
 const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
-async function createProject(projectName) {
-    console.log(chalk_1.default.bold.cyan("\n Create StackKit App\n"));
-    // Get project configuration through wizard
-    const config = await getProjectConfig(projectName);
-    // Validate target directory
+const file_utils_1 = require("./utils/file-utils");
+const git_utils_1 = require("./utils/git-utils");
+const js_conversion_1 = require("./utils/js-conversion");
+const logger_1 = require("./utils/logger");
+const module_utils_1 = require("./utils/module-utils");
+const package_utils_1 = require("./utils/package-utils");
+async function createProject(projectName, options) {
+    logger_1.logger.newLine();
+    logger_1.logger.log(chalk_1.default.bold.cyan("Create StackKit App"));
+    logger_1.logger.newLine();
+    const config = await getProjectConfig(projectName, options);
     const targetDir = path_1.default.join(process.cwd(), config.projectName);
     if (await fs_extra_1.default.pathExists(targetDir)) {
-        console.log(chalk_1.default.red(`\n✖ Directory "${config.projectName}" already exists`));
-        console.log(chalk_1.default.gray("Please choose a different name or remove the existing directory.\n"));
+        logger_1.logger.error(`Directory "${config.projectName}" already exists`);
+        logger_1.logger.log(chalk_1.default.gray("Please choose a different name or remove the existing directory.\n"));
         process.exit(1);
     }
-    // Create project
-    await generateProject(config, targetDir);
-    // Show next steps
+    await generateProject(config, targetDir, options);
     showNextSteps(config);
 }
-async function getProjectConfig(projectName) {
-    const answers = await inquirer_1.default.prompt([
+async function getProjectConfig(projectName, options) {
+    if (options && Object.keys(options).length > 0) {
+        if (options.yes || options.y) {
+            return {
+                projectName: projectName || "my-app",
+                framework: "nextjs",
+                database: "prisma",
+                dbProvider: "postgresql",
+                auth: "better-auth",
+                language: "typescript",
+                packageManager: "pnpm",
+            };
+        }
+        // Validate options
+        const validFrameworks = ['nextjs', 'express', 'react-vite'];
+        const framework = options.framework || options.f;
+        if (framework && !validFrameworks.includes(framework)) {
+            throw new Error(`Invalid framework: ${framework}. Valid options: ${validFrameworks.join(', ')}`);
+        }
+        const validDatabases = ['prisma-postgresql', 'prisma-mongodb', 'prisma-mysql', 'prisma-sqlite', 'mongoose-mongodb', 'none'];
+        const db = options.database || options.d;
+        if (db && !validDatabases.includes(db)) {
+            throw new Error(`Invalid database: ${db}. Valid options: ${validDatabases.join(', ')}`);
+        }
+        const validAuth = ['better-auth', 'authjs', 'none'];
+        const authOpt = options.auth || options.a;
+        if (authOpt && !validAuth.includes(authOpt)) {
+            throw new Error(`Invalid auth: ${authOpt}. Valid options: ${validAuth.join(', ')}`);
+        }
+        const validLanguages = ['typescript', 'javascript'];
+        const language = options.language || options.l;
+        if (language && !validLanguages.includes(language)) {
+            throw new Error(`Invalid language: ${language}. Valid options: ${validLanguages.join(', ')}`);
+        }
+        const validPackageManagers = ['pnpm', 'npm', 'yarn', 'bun'];
+        const pm = options.packageManager || options.p;
+        if (pm && !validPackageManagers.includes(pm)) {
+            throw new Error(`Invalid package manager: ${pm}. Valid options: ${validPackageManagers.join(', ')}`);
+        }
+        let database = "none";
+        let dbProvider;
+        if (db && db !== "none") {
+            if (db.startsWith("prisma-")) {
+                database = "prisma";
+                const provider = db.split("-")[1];
+                if (!["postgresql", "mongodb", "mysql", "sqlite"].includes(provider)) {
+                    throw new Error(`Invalid Prisma provider: ${provider}`);
+                }
+                dbProvider = provider;
+            }
+            else if (db === "mongoose-mongodb") {
+                database = "mongoose";
+            }
+            else {
+                throw new Error(`Unsupported database: ${db}`);
+            }
+        }
+        let auth = "none";
+        if (authOpt && authOpt !== "none") {
+            auth = authOpt;
+        }
+        const finalFramework = (framework || "nextjs");
+        if (finalFramework === "react-vite") {
+            database = "none";
+            dbProvider = undefined;
+        }
+        // Validate auth compatibility
+        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-vite") {
+            throw new Error("Better Auth requires a database for server frameworks");
+        }
+        return {
+            projectName: projectName || "my-app",
+            framework: finalFramework,
+            database,
+            dbProvider,
+            auth,
+            language: (language || "typescript"),
+            packageManager: (pm || "pnpm"),
+        };
+    }
+    const answers = (await inquirer_1.default.prompt([
         {
             type: "input",
             name: "projectName",
@@ -62,41 +147,54 @@ async function getProjectConfig(projectName) {
             message: "Select database/ORM:",
             when: (answers) => answers.framework !== "react-vite",
             choices: [
-                { name: "Prisma + PostgreSQL", value: "prisma-postgresql" },
-                { name: "Prisma + MongoDB", value: "prisma-mongodb" },
-                { name: "Mongoose + MongoDB", value: "mongoose-mongodb" },
+                { name: "Prisma", value: "prisma" },
+                { name: "Mongoose (MongoDB)", value: "mongoose" },
                 { name: "None", value: "none" },
             ],
         },
+        {
+            type: "list",
+            name: "dbProvider",
+            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" },
+            ],
+        },
         {
             type: "list",
             name: "auth",
             message: "Select authentication:",
+            when: (answers) => (answers.database !== "none" || answers.framework === "react-vite") && answers.database !== "mongoose",
             choices: (answers) => {
                 if (answers.framework === "react-vite") {
                     return [
-                        { name: "Better Auth", value: "better-auth-react" },
-                        { name: "Clerk", value: "clerk-react" },
+                        { name: "Better Auth", value: "better-auth" },
+                        { name: "None", value: "none" },
+                    ];
+                }
+                if (answers.database === "mongoose") {
+                    return [
+                        { name: "Better Auth", value: "better-auth" },
                         { name: "None", value: "none" },
                     ];
                 }
-                // Next.js apps
-                if (answers.framework === "nextjs") {
+                if (answers.framework === "nextjs" && answers.database === "prisma") {
                     return [
-                        { name: "Better Auth", value: "better-auth-nextjs" },
-                        { name: "Clerk", value: "clerk-nextjs" },
+                        { name: "Better Auth", value: "better-auth" },
+                        { name: "Auth.js", value: "authjs" },
                         { name: "None", value: "none" },
                     ];
                 }
-                // Express apps
-                if (answers.framework === "express") {
+                if (answers.framework === "express" && answers.database === "prisma") {
                     return [
-                        { name: "Better Auth", value: "better-auth-express" },
-                        { name: "Clerk", value: "clerk-express" },
+                        { name: "Better Auth", value: "better-auth" },
                         { name: "None", value: "none" },
                     ];
                 }
-                // Default - no auth
                 return [{ name: "None", value: "none" }];
             },
         },
@@ -122,22 +220,24 @@ async function getProjectConfig(projectName) {
             ],
             default: "pnpm",
         },
-    ]);
+    ]));
     return {
-        projectName: projectName || answers.projectName,
+        projectName: (projectName || answers.projectName),
         framework: answers.framework,
-        database: answers.framework === "react-vite" ? "none" : answers.database,
-        auth: answers.auth,
+        database: (answers.framework === "react-vite"
+            ? "none"
+            : answers.database),
+        dbProvider: answers.dbProvider,
+        auth: answers.database === "mongoose" ? "better-auth" : (answers.auth || "none"),
         language: answers.language,
         packageManager: answers.packageManager,
     };
 }
-async function generateProject(config, targetDir) {
-    console.log();
-    // Copy and compose template
-    const copySpinner = (0, ora_1.default)("Creating project files...").start();
+async function generateProject(config, targetDir, options) {
+    const copySpinner = logger_1.logger.startSpinner("Creating project files...");
+    let postInstallCommands = [];
     try {
-        await composeTemplate(config, targetDir);
+        postInstallCommands = await composeTemplate(config, targetDir);
         copySpinner.succeed("Project files created");
     }
     catch (error) {
@@ -145,559 +245,84 @@ async function generateProject(config, targetDir) {
         throw error;
     }
     // Install dependencies
-    const installSpinner = (0, ora_1.default)("Installing dependencies...").start();
-    try {
-        await installDependencies(targetDir, config.packageManager);
-        installSpinner.succeed("Dependencies installed");
-    }
-    catch (error) {
-        installSpinner.fail("Failed to install dependencies");
-        throw error;
-    }
-    // Initialize git
-    const gitSpinner = (0, ora_1.default)("Initializing git repository...").start();
-    try {
-        await initGit(targetDir);
-        gitSpinner.succeed("Git repository initialized");
-    }
-    catch (error) {
-        gitSpinner.warn("Failed to initialize git repository");
-    }
-}
-async function composeTemplate(config, targetDir) {
-    const templatesDir = path_1.default.join(__dirname, "..", "..", "templates");
-    await fs_extra_1.default.ensureDir(targetDir);
-    // 1. Copy base framework template
-    await copyBaseFramework(templatesDir, targetDir, config.framework);
-    // 2. Merge database configuration
-    if (config.database !== "none") {
-        await mergeDatabaseConfig(templatesDir, targetDir, config.database, config.framework);
-    }
-    // 3. Merge auth configuration
-    if (config.auth !== "none") {
-        await mergeAuthConfig(templatesDir, targetDir, config.framework, config.auth, config.database);
-    }
-    // 4. Update package.json with project name
-    const packageJsonPath = path_1.default.join(targetDir, "package.json");
-    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
-        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
-        packageJson.name = config.projectName;
-        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-    }
-    // 5. Convert to JavaScript if selected
-    if (config.language === "javascript") {
-        await convertToJavaScript(targetDir, config.framework);
-    }
-}
-async function copyBaseFramework(templatesDir, targetDir, framework) {
-    const baseDir = path_1.default.join(templatesDir, framework);
-    if (!(await fs_extra_1.default.pathExists(baseDir))) {
-        throw new Error(`Base template not found for framework: ${framework}\n` + `Expected at: ${baseDir}`);
-    }
-    await fs_extra_1.default.copy(baseDir, targetDir, {
-        filter: (src) => {
-            const basename = path_1.default.basename(src);
-            return !["template.json", "config.json", "node_modules", ".git"].includes(basename);
-        },
-    });
-}
-async function mergeDatabaseConfig(templatesDir, targetDir, database, framework) {
-    // Use modules directory (sibling to templates)
-    const modulesDir = path_1.default.join(templatesDir, "..", "modules");
-    const dbModulePath = path_1.default.join(modulesDir, "database", database);
-    if (!(await fs_extra_1.default.pathExists(dbModulePath))) {
-        console.warn(`Database module not found: ${database}`);
-        return;
-    }
-    // Read module.json
-    const moduleJsonPath = path_1.default.join(dbModulePath, "module.json");
-    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
-        return;
-    }
-    const moduleData = await fs_extra_1.default.readJson(moduleJsonPath);
-    // Copy files from module
-    const filesDir = path_1.default.join(dbModulePath, "files");
-    if (await fs_extra_1.default.pathExists(filesDir)) {
-        // Copy files based on patches in module.json
-        for (const patch of moduleData.patches || []) {
-            if (patch.type === "create-file") {
-                const sourceFile = path_1.default.join(filesDir, patch.source);
-                let destFile = path_1.default.join(targetDir, patch.destination);
-                // Simple placeholder replacement for lib
-                destFile = destFile.replace("{{lib}}", "lib").replace("{{src}}", "src");
-                if (await fs_extra_1.default.pathExists(sourceFile)) {
-                    await fs_extra_1.default.ensureDir(path_1.default.dirname(destFile));
-                    await fs_extra_1.default.copy(sourceFile, destFile, { overwrite: false });
-                }
-            }
+    if (options?.install !== false && !options?.['skip-install']) {
+        const installSpinner = logger_1.logger.startSpinner("Installing dependencies...");
+        try {
+            await (0, package_utils_1.installDependencies)(targetDir, config.packageManager);
+            installSpinner.succeed("Dependencies installed");
         }
-    }
-    // Merge package.json with module dependencies
-    await mergePackageJson(targetDir, {
-        dependencies: moduleData.dependencies,
-        devDependencies: moduleData.devDependencies,
-    });
-    // Merge .env with module envVars
-    const envVars = {};
-    for (const envVar of moduleData.envVars || []) {
-        envVars[envVar.key] = envVar.value;
-    }
-    await mergeEnvFile(targetDir, envVars);
-    // Apply framework-specific patches from database module
-    if (moduleData.frameworkPatches) {
-        const frameworkKey = framework === "react-vite" ? "react" : framework;
-        const patches = moduleData.frameworkPatches[frameworkKey];
-        if (patches) {
-            await applyFrameworkPatches(targetDir, patches);
+        catch (error) {
+            installSpinner.fail("Failed to install dependencies");
+            throw error;
         }
     }
-}
-async function mergeAuthConfig(templatesDir, targetDir, framework, auth, database = "none") {
-    // Use modules directory (sibling to templates)
-    const modulesDir = path_1.default.join(templatesDir, "..", "modules");
-    // Auth modules are now named with framework suffix
-    // e.g., better-auth-nextjs, authjs-express, better-auth-react
-    // If auth already has framework suffix, use it directly
-    // Otherwise, map old names to new ones
-    const authMap = {
-        nextauth: "nextauth",
-        "better-auth": framework === "nextjs" ? "better-auth-nextjs" : "better-auth-express",
-        clerk: framework === "nextjs"
-            ? "clerk-nextjs"
-            : framework === "react-vite"
-                ? "clerk-react"
-                : "clerk-express",
-    };
-    const authKey = auth.includes("-") ? auth : authMap[auth] || auth;
-    const authModulePath = path_1.default.join(modulesDir, "auth", authKey);
-    if (!(await fs_extra_1.default.pathExists(authModulePath))) {
-        console.warn(`Auth module not found: ${authKey}`);
-        return;
-    }
-    // Read module.json
-    const moduleJsonPath = path_1.default.join(authModulePath, "module.json");
-    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
-        return;
-    }
-    const moduleData = await fs_extra_1.default.readJson(moduleJsonPath);
-    // Copy files from module
-    const filesDir = path_1.default.join(authModulePath, "files");
-    if (await fs_extra_1.default.pathExists(filesDir)) {
-        // Determine path replacements based on framework
-        const getReplacements = () => {
-            if (framework === "nextjs") {
-                return { lib: "lib", router: "app" };
-            }
-            else if (framework === "express") {
-                return { lib: "src", router: "src" };
-            }
-            else {
-                return { lib: "src", router: "src" };
-            }
-        };
-        const replacements = getReplacements();
-        // Copy files based on patches in module.json
-        for (const patch of moduleData.patches || []) {
-            if (patch.type === "create-file") {
-                const sourceFile = path_1.default.join(filesDir, patch.source);
-                let destFile = path_1.default.join(targetDir, patch.destination);
-                // Replace placeholders
-                destFile = destFile
-                    .replace("{{lib}}", replacements.lib)
-                    .replace("{{router}}", replacements.router);
-                if (await fs_extra_1.default.pathExists(sourceFile)) {
-                    await fs_extra_1.default.ensureDir(path_1.default.dirname(destFile));
-                    await fs_extra_1.default.copy(sourceFile, destFile, { overwrite: false });
-                }
-            }
-        }
-    }
-    // Handle database-specific adapters and schemas
-    if (database !== "none" && moduleData.databaseAdapters) {
-        const adapterConfig = moduleData.databaseAdapters[database];
-        if (adapterConfig) {
-            // Copy adapter file
-            if (adapterConfig.adapter) {
-                const adapterSource = path_1.default.join(authModulePath, adapterConfig.adapter);
-                const adapterFileName = path_1.default.basename(adapterConfig.adapter);
-                // Determine destination based on framework
-                let adapterDest;
-                if (framework === "nextjs") {
-                    adapterDest = path_1.default.join(targetDir, "lib", "auth.ts");
-                }
-                else if (framework === "express") {
-                    adapterDest = path_1.default.join(targetDir, "src", "auth.ts");
-                }
-                else {
-                    adapterDest = path_1.default.join(targetDir, "src", "lib", "auth.ts");
-                }
-                if (await fs_extra_1.default.pathExists(adapterSource)) {
-                    await fs_extra_1.default.ensureDir(path_1.default.dirname(adapterDest));
-                    await fs_extra_1.default.copy(adapterSource, adapterDest, { overwrite: true });
-                }
-            }
-            // Copy schema file if it exists
-            if (adapterConfig.schema && adapterConfig.schemaDestination) {
-                const schemaSource = path_1.default.join(authModulePath, adapterConfig.schema);
-                const schemaDest = path_1.default.join(targetDir, adapterConfig.schemaDestination);
-                if (await fs_extra_1.default.pathExists(schemaSource)) {
-                    await fs_extra_1.default.ensureDir(path_1.default.dirname(schemaDest));
-                    await fs_extra_1.default.copy(schemaSource, schemaDest, { overwrite: true });
-                }
-            }
-            // Merge adapter-specific dependencies
-            if (adapterConfig.dependencies) {
-                await mergePackageJson(targetDir, {
-                    dependencies: adapterConfig.dependencies,
-                });
+    // Run post-install commands
+    if (postInstallCommands.length > 0) {
+        const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
+        try {
+            for (const command of postInstallCommands) {
+                (0, child_process_1.execSync)(command, { cwd: targetDir, stdio: "pipe" });
             }
+            postInstallSpinner.succeed("Post-install commands completed");
         }
-    }
-    // Merge package.json with module dependencies
-    await mergePackageJson(targetDir, {
-        dependencies: moduleData.dependencies,
-        devDependencies: moduleData.devDependencies,
-    });
-    // Merge .env with module envVars
-    const envVars = {};
-    for (const envVar of moduleData.envVars || []) {
-        envVars[envVar.key] = envVar.value;
-    }
-    await mergeEnvFile(targetDir, envVars);
-}
-async function mergePackageJson(targetDir, config) {
-    const pkgPath = path_1.default.join(targetDir, "package.json");
-    if (!(await fs_extra_1.default.pathExists(pkgPath))) {
-        return;
-    }
-    const pkg = await fs_extra_1.default.readJson(pkgPath);
-    if (config.dependencies) {
-        pkg.dependencies = { ...pkg.dependencies, ...config.dependencies };
-    }
-    if (config.devDependencies) {
-        pkg.devDependencies = { ...pkg.devDependencies, ...config.devDependencies };
-    }
-    if (config.scripts) {
-        pkg.scripts = { ...pkg.scripts, ...config.scripts };
-    }
-    await fs_extra_1.default.writeJson(pkgPath, pkg, { spaces: 2 });
-}
-async function mergeEnvFile(targetDir, envVars) {
-    if (Object.keys(envVars).length === 0) {
-        return;
-    }
-    const envExamplePath = path_1.default.join(targetDir, ".env.example");
-    const envPath = path_1.default.join(targetDir, ".env");
-    const envContent = Object.entries(envVars)
-        .map(([key, value]) => `${key}="${value}"`)
-        .join("\n") + "\n";
-    // Update .env.example
-    if (await fs_extra_1.default.pathExists(envExamplePath)) {
-        const existing = await fs_extra_1.default.readFile(envExamplePath, "utf-8");
-        const existingKeys = existing.split("\n").map((line) => line.split("=")[0]);
-        const newVars = Object.keys(envVars).filter((key) => !existingKeys.includes(key));
-        if (newVars.length > 0) {
-            const newContent = newVars.map((key) => `${key}="${envVars[key]}"`).join("\n");
-            await fs_extra_1.default.appendFile(envExamplePath, "\n" + newContent + "\n");
-        }
-    }
-    else {
-        await fs_extra_1.default.writeFile(envExamplePath, envContent);
-    }
-    // Create .env if doesn't exist
-    if (!(await fs_extra_1.default.pathExists(envPath))) {
-        await fs_extra_1.default.writeFile(envPath, envContent);
-    }
-}
-async function convertToJavaScript(targetDir, framework) {
-    // Remove TS config and declaration files
-    const tsFiles = [
-        "tsconfig.json",
-        "tsconfig.app.json",
-        "tsconfig.node.json",
-        "next-env.d.ts",
-        "vite-env.d.ts",
-    ];
-    for (const file of tsFiles) {
-        const filePath = path_1.default.join(targetDir, file);
-        if (await fs_extra_1.default.pathExists(filePath)) {
-            await fs_extra_1.default.remove(filePath);
+        catch (error) {
+            postInstallSpinner.fail("Failed to run post-install commands");
+            throw error;
         }
     }
-    const removeDtsFiles = async (dir) => {
-        const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path_1.default.join(dir, entry.name);
-            if (entry.isDirectory() && entry.name !== "node_modules") {
-                await removeDtsFiles(fullPath);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".d.ts")) {
-                await fs_extra_1.default.remove(fullPath);
-            }
-        }
-    };
-    await removeDtsFiles(targetDir);
-    // Use Babel to strip types only, preserving exact formatting/comments/blank lines, producing clean production-ready code
-    const babel = require("@babel/core");
-    const transpileAllTsFiles = async (dir) => {
-        const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path_1.default.join(dir, entry.name);
-            if (entry.isDirectory() && entry.name !== "node_modules") {
-                await transpileAllTsFiles(fullPath);
-            }
-            else if (entry.isFile()) {
-                if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
-                    const code = await fs_extra_1.default.readFile(fullPath, "utf8");
-                    const isTsx = entry.name.endsWith(".tsx");
-                    const outFile = fullPath.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
-                    const presets = [
-                        [
-                            require.resolve("@babel/preset-typescript"),
-                            {
-                                onlyRemoveTypeImports: true,
-                                allowDeclareFields: true,
-                                allowNamespaces: true,
-                                optimizeForSpeed: true,
-                                allExtensions: true,
-                                isTSX: isTsx,
-                            },
-                        ],
-                        [
-                            require.resolve("@babel/preset-env"),
-                            {
-                                targets: { node: "18" },
-                                modules: false,
-                            },
-                        ],
-                    ];
-                    if (isTsx) {
-                        presets.push([
-                            require.resolve("@babel/preset-react"),
-                            {
-                                runtime: "automatic",
-                            },
-                        ]);
-                    }
-                    // Use recast + Babel AST transform (same approach as transform.tools)
-                    try {
-                        const recast = require("recast");
-                        const { transformFromAstSync } = require("@babel/core");
-                        const transformTypescript = require("@babel/plugin-transform-typescript");
-                        // getBabelOptions may be exported as default or directly
-                        let getBabelOptions = require("recast/parsers/_babel_options");
-                        if (getBabelOptions && getBabelOptions.default)
-                            getBabelOptions = getBabelOptions.default;
-                        const babelParser = require("recast/parsers/babel").parser;
-                        const ast = recast.parse(code, {
-                            parser: {
-                                parse: (source, options) => {
-                                    const babelOptions = getBabelOptions(options || {});
-                                    // ensure typescript and jsx handling
-                                    if (isTsx) {
-                                        babelOptions.plugins.push("typescript", "jsx");
-                                    }
-                                    else {
-                                        babelOptions.plugins.push("typescript");
-                                    }
-                                    return babelParser.parse(source, babelOptions);
-                                },
-                            },
-                        });
-                        const opts = {
-                            cloneInputAst: false,
-                            code: false,
-                            ast: true,
-                            plugins: [transformTypescript],
-                            configFile: false,
-                        };
-                        const { ast: transformedAST } = transformFromAstSync(ast, code, opts);
-                        const resultCode = recast.print(transformedAST).code;
-                        await fs_extra_1.default.writeFile(outFile, resultCode, "utf8");
-                        await fs_extra_1.default.remove(fullPath);
-                        continue;
-                    }
-                    catch (e) {
-                        // fallback to previous Babel pipeline if anything fails
-                    }
-                    const result = await babel.transformAsync(code, {
-                        filename: entry.name,
-                        presets,
-                        comments: true,
-                        retainLines: true,
-                        compact: false,
-                        babelrc: false,
-                        configFile: false,
-                    });
-                    await fs_extra_1.default.writeFile(outFile, result.code, "utf8");
-                    await fs_extra_1.default.remove(fullPath);
-                }
-            }
+    // Initialize git
+    if (options?.git !== false && !options?.['no-git']) {
+        const gitSpinner = logger_1.logger.startSpinner("Initializing git repository...");
+        try {
+            await (0, git_utils_1.initGit)(targetDir);
+            gitSpinner.succeed("Git repository initialized");
         }
-    };
-    await transpileAllTsFiles(targetDir);
-    const templatesRoot = path_1.default.join(__dirname, "..", "..", "templates");
-    const templateName = framework;
-    let fileReplacements = [];
-    let jsScripts = null;
-    if (templateName) {
-        const templateJsonPath = path_1.default.join(templatesRoot, templateName, "template.json");
-        if (await fs_extra_1.default.pathExists(templateJsonPath)) {
-            try {
-                const templateJson = await fs_extra_1.default.readJson(templateJsonPath);
-                if (Array.isArray(templateJson.fileReplacements)) {
-                    fileReplacements = templateJson.fileReplacements;
-                }
-                if (templateJson.jsScripts) {
-                    jsScripts = templateJson.jsScripts;
-                }
-            }
-            catch { }
+        catch {
+            gitSpinner.warn("Failed to initialize git repository");
         }
     }
-    for (const rep of fileReplacements) {
-        const filePath = path_1.default.join(targetDir, rep.file);
-        if (await fs_extra_1.default.pathExists(filePath)) {
-            let content = await fs_extra_1.default.readFile(filePath, "utf8");
-            if (rep.from && rep.to) {
-                content = content.replace(rep.from, rep.to);
-                await fs_extra_1.default.writeFile(filePath, content, "utf8");
-            }
+}
+async function composeTemplate(config, targetDir) {
+    const templatesDir = path_1.default.join(__dirname, "..", "..", "templates");
+    await fs_extra_1.default.ensureDir(targetDir);
+    await (0, file_utils_1.copyBaseFramework)(templatesDir, targetDir, config.framework);
+    // Ensure .env exists: if .env.example was copied from the template, create .env from it
+    try {
+        const envExamplePath = path_1.default.join(targetDir, ".env.example");
+        const envPath = path_1.default.join(targetDir, ".env");
+        if ((await fs_extra_1.default.pathExists(envExamplePath)) && !(await fs_extra_1.default.pathExists(envPath))) {
+            const envContent = await fs_extra_1.default.readFile(envExamplePath, "utf-8");
+            await fs_extra_1.default.writeFile(envPath, envContent);
         }
     }
-    if (jsScripts) {
-        const packageJsonPath = path_1.default.join(targetDir, "package.json");
-        if (await fs_extra_1.default.pathExists(packageJsonPath)) {
-            const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
-            packageJson.scripts = { ...packageJson.scripts, ...jsScripts };
-            await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-        }
+    catch {
+        // non-fatal
     }
-    const jsconfig = path_1.default.join(targetDir, "jsconfig.json");
-    if (!(await fs_extra_1.default.pathExists(jsconfig))) {
-        for (const tmpl of await fs_extra_1.default.readdir(templatesRoot, { withFileTypes: true })) {
-            if (tmpl.isDirectory()) {
-                const templateJsconfig = path_1.default.join(templatesRoot, tmpl.name, "jsconfig.json");
-                if (await fs_extra_1.default.pathExists(templateJsconfig)) {
-                    await fs_extra_1.default.copy(templateJsconfig, jsconfig);
-                    break;
-                }
-            }
-        }
+    const postInstallCommands = [];
+    if (config.database !== "none") {
+        const dbPostInstall = await (0, module_utils_1.mergeDatabaseConfig)(templatesDir, targetDir, config.database, config.framework, config.dbProvider);
+        postInstallCommands.push(...dbPostInstall);
     }
-    const srcDir = path_1.default.join(targetDir, "src");
-    if (await fs_extra_1.default.pathExists(srcDir)) {
-        const srcFiles = await fs_extra_1.default.readdir(srcDir);
-        for (const file of srcFiles) {
-            if ((file.endsWith(".js") || file.endsWith(".jsx")) &&
-                file.replace(/\.(js|jsx)$/, ".ts") &&
-                srcFiles.includes(file.replace(/\.(js|jsx)$/, ".ts"))) {
-                await fs_extra_1.default.remove(path_1.default.join(srcDir, file.replace(/\.(js|jsx)$/, ".ts")));
-            }
-            if (file.endsWith(".jsx") && srcFiles.includes(file.replace(/\.jsx$/, ".tsx"))) {
-                await fs_extra_1.default.remove(path_1.default.join(srcDir, file.replace(/\.jsx$/, ".tsx")));
-            }
-        }
+    if (config.auth !== "none") {
+        await (0, module_utils_1.mergeAuthConfig)(templatesDir, targetDir, config.framework, config.auth, config.database, config.dbProvider);
     }
     const packageJsonPath = path_1.default.join(targetDir, "package.json");
     if (await fs_extra_1.default.pathExists(packageJsonPath)) {
         const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
-        if (packageJson.devDependencies) {
-            delete packageJson.devDependencies["typescript"];
-            delete packageJson.devDependencies["@types/node"];
-            delete packageJson.devDependencies["@types/react"];
-            delete packageJson.devDependencies["@types/react-dom"];
-        }
+        packageJson.name = config.projectName;
         await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
     }
-}
-async function installDependencies(cwd, packageManager) {
-    const commands = {
-        npm: "npm install",
-        yarn: "yarn install",
-        pnpm: "pnpm install",
-        bun: "bun install",
-    };
-    const isAvailable = (cmd) => {
-        try {
-            (0, child_process_1.execSync)(`command -v ${cmd}`, { stdio: "ignore" });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    let chosen = packageManager;
-    // If requested package manager is not available, try to fall back to a common one
-    if (!isAvailable(chosen)) {
-        const fallbacks = ["pnpm", "npm", "yarn", "bun"];
-        const found = fallbacks.find((p) => isAvailable(p));
-        if (found) {
-            console.warn(`Selected package manager '${chosen}' was not found. Falling back to '${found}'.`);
-            chosen = found;
-        }
-        else {
-            throw new Error(`Selected package manager '${packageManager}' was not found and no fallback package manager is available. Please install '${packageManager}' or use a different package manager.`);
-        }
-    }
-    const command = commands[chosen];
-    (0, child_process_1.execSync)(command, {
-        cwd,
-        stdio: "pipe",
-    });
-}
-async function initGit(cwd) {
-    try {
-        (0, child_process_1.execSync)("git --version", { stdio: "pipe" });
-        (0, child_process_1.execSync)("git init", { cwd, stdio: "pipe" });
-        (0, child_process_1.execSync)("git add -A", { cwd, stdio: "pipe" });
-        (0, child_process_1.execSync)('git commit -m "Initial commit from create-stackkit-app"', {
-            cwd,
-            stdio: "pipe",
-        });
-    }
-    catch (error) {
-        throw new Error("Git initialization failed");
-    }
-}
-async function applyFrameworkPatches(targetDir, patches) {
-    for (const [filename, patchConfig] of Object.entries(patches)) {
-        const filePath = path_1.default.join(targetDir, filename);
-        if (await fs_extra_1.default.pathExists(filePath)) {
-            const fileContent = await fs_extra_1.default.readJson(filePath);
-            if (patchConfig.merge) {
-                // Deep merge configuration
-                const merged = deepMerge(fileContent, patchConfig.merge);
-                await fs_extra_1.default.writeJson(filePath, merged, { spaces: 2 });
-            }
-        }
-    }
-}
-function deepMerge(target, source) {
-    const output = { ...target };
-    for (const key in source) {
-        if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
-            if (target[key]) {
-                output[key] = deepMerge(target[key], source[key]);
-            }
-            else {
-                output[key] = source[key];
-            }
-        }
-        else if (Array.isArray(source[key])) {
-            // For arrays, merge uniquely
-            output[key] = Array.from(new Set([...(target[key] || []), ...source[key]]));
-        }
-        else {
-            output[key] = source[key];
-        }
+    if (config.language === "javascript") {
+        await (0, js_conversion_1.convertToJavaScript)(targetDir, config.framework);
     }
-    return output;
+    return postInstallCommands;
 }
 function showNextSteps(config) {
-    console.log(chalk_1.default.green.bold(`\n✓ Created ${config.projectName}\n`));
-    console.log(chalk_1.default.bold("Next steps:"));
-    console.log(chalk_1.default.cyan(`  cd ${config.projectName}`));
-    // Only `bun` is supported as the package manager in production-ready CLI
-    console.log(chalk_1.default.cyan("  bun run dev\n"));
+    logger_1.logger.newLine();
+    logger_1.logger.success(`Created ${config.projectName}`);
+    logger_1.logger.newLine();
+    logger_1.logger.log("Next steps:");
+    logger_1.logger.log(`  cd ${config.projectName}`);
+    logger_1.logger.log(`  ${config.packageManager} run dev`);
+    logger_1.logger.newLine();
 }