create-stackkit-app 0.4.3 → 0.4.4

package/dist/lib/create-project.js

@@ -11,24 +11,28 @@ 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"));
+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 module_utils_1 = require("./utils/module-utils");
+const package_utils_1 = require("./utils/package-utils");
 async function createProject(projectName) {
+    // eslint-disable-next-line no-console
     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 targetDir = path_1.default.join(process.cwd(), config.projectName);
     if (await fs_extra_1.default.pathExists(targetDir)) {
+        // eslint-disable-next-line no-console
         console.log(chalk_1.default.red(`\n✖ Directory "${config.projectName}" already exists`));
+        // eslint-disable-next-line no-console
         console.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
     showNextSteps(config);
 }
 async function getProjectConfig(projectName) {
-    const answers = await inquirer_1.default.prompt([
+    const answers = (await inquirer_1.default.prompt([
         {
             type: "input",
             name: "projectName",
@@ -62,37 +66,49 @@ 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: "Prisma", value: "prisma" },
                 { name: "Mongoose + MongoDB", value: "mongoose-mongodb" },
                 { 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",
             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: "Clerk", value: "clerk" },
                         { name: "None", value: "none" },
                     ];
                 }
                 // Next.js apps
                 if (answers.framework === "nextjs") {
                     return [
-                        { name: "Better Auth", value: "better-auth-nextjs" },
-                        { name: "Clerk", value: "clerk-nextjs" },
+                        { name: "Better Auth", value: "better-auth" },
+                        { name: "Clerk", value: "clerk" },
                         { name: "None", value: "none" },
                     ];
                 }
                 // Express apps
                 if (answers.framework === "express") {
                     return [
-                        { name: "Better Auth", value: "better-auth-express" },
-                        { name: "Clerk", value: "clerk-express" },
+                        { name: "Better Auth", value: "better-auth" },
+                        { name: "Clerk", value: "clerk" },
                         { name: "None", value: "none" },
                     ];
                 }
@@ -122,22 +138,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.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();
+    let postInstallCommands = [];
     try {
-        await composeTemplate(config, targetDir);
+        postInstallCommands = await composeTemplate(config, targetDir);
         copySpinner.succeed("Project files created");
     }
     catch (error) {
@@ -147,557 +165,79 @@ async function generateProject(config, targetDir) {
     // Install dependencies
     const installSpinner = (0, ora_1.default)("Installing dependencies...").start();
     try {
-        await installDependencies(targetDir, config.packageManager);
+        await (0, package_utils_1.installDependencies)(targetDir, config.packageManager);
         installSpinner.succeed("Dependencies installed");
     }
     catch (error) {
         installSpinner.fail("Failed to install dependencies");
         throw error;
     }
+    // Run post-install commands
+    if (postInstallCommands.length > 0) {
+        const postInstallSpinner = (0, ora_1.default)("Running post-install commands...").start();
+        try {
+            for (const command of postInstallCommands) {
+                (0, child_process_1.execSync)(command, { cwd: targetDir, stdio: "pipe" });
+            }
+            postInstallSpinner.succeed("Post-install commands completed");
+        }
+        catch (error) {
+            postInstallSpinner.fail("Failed to run post-install commands");
+            throw error;
+        }
+    }
     // Initialize git
     const gitSpinner = (0, ora_1.default)("Initializing git repository...").start();
     try {
-        await initGit(targetDir);
+        await (0, git_utils_1.initGit)(targetDir);
         gitSpinner.succeed("Git repository initialized");
     }
-    catch (error) {
+    catch {
         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
+    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);
+        }
+    }
+    catch {
+        // non-fatal
+    }
+    const postInstallCommands = [];
     if (config.database !== "none") {
-        await mergeDatabaseConfig(templatesDir, targetDir, config.database, config.framework);
+        const dbPostInstall = await (0, module_utils_1.mergeDatabaseConfig)(templatesDir, targetDir, config.database, config.framework, config.dbProvider);
+        postInstallCommands.push(...dbPostInstall);
     }
-    // 3. Merge auth configuration
     if (config.auth !== "none") {
-        await mergeAuthConfig(templatesDir, targetDir, config.framework, config.auth, config.database);
+        await (0, module_utils_1.mergeAuthConfig)(templatesDir, targetDir, config.framework, config.auth, config.database, config.dbProvider);
     }
-    // 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 });
-                }
-            }
-        }
-    }
-    // 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);
-        }
-    }
-}
-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,
-                });
-            }
-        }
-    }
-    // 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);
-        }
-    }
-    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);
-                }
-            }
-        }
-    };
-    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 { }
-        }
-    }
-    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");
-            }
-        }
-    }
-    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 });
-        }
-    }
-    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 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")));
-            }
-        }
-    }
-    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"];
-        }
-        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];
-        }
+        await (0, js_conversion_1.convertToJavaScript)(targetDir, config.framework);
     }
-    return output;
+    return postInstallCommands;
 }
 function showNextSteps(config) {
+    // eslint-disable-next-line no-console
     console.log(chalk_1.default.green.bold(`\n✓ Created ${config.projectName}\n`));
+    // eslint-disable-next-line no-console
     console.log(chalk_1.default.bold("Next steps:"));
+    // eslint-disable-next-line no-console
     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"));
+    // eslint-disable-next-line no-console
+    console.log(chalk_1.default.cyan(`  ${config.packageManager} run dev\n`));
 }