create-stackkit-app 0.4.1 → 0.4.3

package/dist/lib/create-project.js

@@ -12,14 +12,14 @@ 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'));
+    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)) {
         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'));
+        console.log(chalk_1.default.gray("Please choose a different name or remove the existing directory.\n"));
         process.exit(1);
     }
     // Create project
@@ -30,99 +30,103 @@ async function createProject(projectName) {
 async function getProjectConfig(projectName) {
     const answers = await inquirer_1.default.prompt([
         {
-            type: 'input',
-            name: 'projectName',
-            message: 'Project name:',
-            default: projectName || 'my-app',
+            type: "input",
+            name: "projectName",
+            message: "Project name:",
+            default: projectName || "my-app",
             when: !projectName,
             validate: (input) => {
                 const validation = (0, validate_npm_package_name_1.default)(input);
                 if (!validation.validForNewPackages) {
-                    return validation.errors?.[0] || 'Invalid package name';
+                    return validation.errors?.[0] || "Invalid package name";
                 }
                 if (fs_extra_1.default.existsSync(path_1.default.join(process.cwd(), input))) {
-                    return 'Directory already exists';
+                    return "Directory already exists";
                 }
                 return true;
             },
         },
         {
-            type: 'list',
-            name: 'framework',
-            message: 'Select framework:',
+            type: "list",
+            name: "framework",
+            message: "Select framework:",
             choices: [
-                { name: 'Next.js', value: 'nextjs' },
-                { name: 'Express.js', value: 'express' },
-                { name: 'React (Vite)', value: 'react-vite' },
+                { name: "Next.js", value: "nextjs" },
+                { name: "Express.js", value: "express" },
+                { name: "React (Vite)", value: "react-vite" },
             ],
         },
         {
-            type: 'list',
-            name: 'database',
-            message: 'Select database/ORM:',
-            when: (answers) => answers.framework !== 'react-vite',
+            type: "list",
+            name: "database",
+            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: 'Drizzle + PostgreSQL', value: 'drizzle-postgresql' },
-                { name: 'None', value: 'none' },
+                { name: "Prisma + PostgreSQL", value: "prisma-postgresql" },
+                { name: "Prisma + MongoDB", value: "prisma-mongodb" },
+                { name: "Mongoose + MongoDB", value: "mongoose-mongodb" },
+                { name: "None", value: "none" },
             ],
         },
         {
-            type: 'list',
-            name: 'auth',
-            message: 'Select authentication:',
+            type: "list",
+            name: "auth",
+            message: "Select authentication:",
             choices: (answers) => {
-                if (answers.framework === 'react-vite') {
+                if (answers.framework === "react-vite") {
                     return [
-                        { name: 'Better Auth', value: 'better-auth-react' },
-                        { name: 'Clerk', value: 'clerk-react' },
-                        { name: 'None', value: 'none' },
+                        { name: "Better Auth", value: "better-auth-react" },
+                        { name: "Clerk", value: "clerk-react" },
+                        { name: "None", value: "none" },
                     ];
                 }
                 // Next.js apps
-                if (answers.framework === 'nextjs') {
+                if (answers.framework === "nextjs") {
                     return [
-                        { name: 'Better Auth', value: 'better-auth-nextjs' },
-                        { name: 'Clerk', value: 'clerk-nextjs' },
-                        { name: 'None', value: 'none' },
+                        { name: "Better Auth", value: "better-auth-nextjs" },
+                        { name: "Clerk", value: "clerk-nextjs" },
+                        { name: "None", value: "none" },
                     ];
                 }
                 // Express apps
-                if (answers.framework === 'express') {
+                if (answers.framework === "express") {
                     return [
-                        { name: 'Better Auth', value: 'better-auth-express' },
-                        { name: 'Clerk', value: 'clerk-express' },
-                        { name: 'None', value: 'none' },
+                        { name: "Better Auth", value: "better-auth-express" },
+                        { name: "Clerk", value: "clerk-express" },
+                        { name: "None", value: "none" },
                     ];
                 }
                 // Default - no auth
-                return [{ name: 'None', value: 'none' }];
+                return [{ name: "None", value: "none" }];
             },
         },
         {
-            type: 'list',
-            name: 'language',
-            message: 'Language:',
+            type: "list",
+            name: "language",
+            message: "Language:",
             choices: [
-                { name: 'TypeScript', value: 'typescript' },
-                { name: 'JavaScript', value: 'javascript' },
+                { name: "TypeScript", value: "typescript" },
+                { name: "JavaScript", value: "javascript" },
             ],
-            default: 'typescript',
+            default: "typescript",
         },
         {
-            type: 'list',
-            name: 'packageManager',
-            message: 'Package manager:',
-            choices: ['pnpm', 'npm', 'yarn'],
-            default: 'pnpm',
+            type: "list",
+            name: "packageManager",
+            message: "Package manager:",
+            choices: [
+                { name: "pnpm (recommended)", value: "pnpm" },
+                { name: "npm", value: "npm" },
+                { name: "yarn", value: "yarn" },
+                { name: "bun", value: "bun" },
+            ],
+            default: "pnpm",
         },
     ]);
     return {
         projectName: projectName || answers.projectName,
         framework: answers.framework,
-        database: answers.framework === 'react-vite' ? 'none' : answers.database,
+        database: answers.framework === "react-vite" ? "none" : answers.database,
         auth: answers.auth,
         language: answers.language,
         packageManager: answers.packageManager,
@@ -131,96 +135,96 @@ async function getProjectConfig(projectName) {
 async function generateProject(config, targetDir) {
     console.log();
     // Copy and compose template
-    const copySpinner = (0, ora_1.default)('Creating project files...').start();
+    const copySpinner = (0, ora_1.default)("Creating project files...").start();
     try {
         await composeTemplate(config, targetDir);
-        copySpinner.succeed('Project files created');
+        copySpinner.succeed("Project files created");
     }
     catch (error) {
-        copySpinner.fail('Failed to create project files');
+        copySpinner.fail("Failed to create project files");
         throw error;
     }
     // Install dependencies
-    const installSpinner = (0, ora_1.default)('Installing dependencies...').start();
+    const installSpinner = (0, ora_1.default)("Installing dependencies...").start();
     try {
         await installDependencies(targetDir, config.packageManager);
-        installSpinner.succeed('Dependencies installed');
+        installSpinner.succeed("Dependencies installed");
     }
     catch (error) {
-        installSpinner.fail('Failed to install dependencies');
+        installSpinner.fail("Failed to install dependencies");
         throw error;
     }
     // Initialize git
-    const gitSpinner = (0, ora_1.default)('Initializing git repository...').start();
+    const gitSpinner = (0, ora_1.default)("Initializing git repository...").start();
     try {
         await initGit(targetDir);
-        gitSpinner.succeed('Git repository initialized');
+        gitSpinner.succeed("Git repository initialized");
     }
     catch (error) {
-        gitSpinner.warn('Failed to initialize git repository');
+        gitSpinner.warn("Failed to initialize git repository");
     }
 }
 async function composeTemplate(config, targetDir) {
-    const templatesDir = path_1.default.join(__dirname, '..', '..', 'templates');
+    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);
+    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);
+    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');
+    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);
+    if (config.language === "javascript") {
+        await convertToJavaScript(targetDir, config.framework);
     }
 }
 async function copyBaseFramework(templatesDir, targetDir, framework) {
-    const baseDir = path_1.default.join(templatesDir, 'bases', `${framework}-base`);
+    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);
+            return !["template.json", "config.json", "node_modules", ".git"].includes(basename);
         },
     });
 }
-async function mergeDatabaseConfig(templatesDir, targetDir, database) {
+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);
+    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');
+    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');
+    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') {
+            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');
+                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 });
@@ -239,60 +243,68 @@ async function mergeDatabaseConfig(templatesDir, targetDir, database) {
         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) {
+async function mergeAuthConfig(templatesDir, targetDir, framework, auth, database = "none") {
     // Use modules directory (sibling to templates)
-    const modulesDir = path_1.default.join(templatesDir, '..', 'modules');
+    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',
+        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);
+    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');
+    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');
+    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' };
+            if (framework === "nextjs") {
+                return { lib: "lib", router: "app" };
             }
-            else if (framework === 'express') {
-                return { lib: 'src', router: 'src' };
+            else if (framework === "express") {
+                return { lib: "src", router: "src" };
             }
             else {
-                return { lib: 'src', router: 'src' };
+                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') {
+            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);
+                    .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 });
@@ -300,6 +312,47 @@ async function mergeAuthConfig(templatesDir, targetDir, framework, auth) {
             }
         }
     }
+    // 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,
@@ -313,7 +366,7 @@ async function mergeAuthConfig(templatesDir, targetDir, framework, auth) {
     await mergeEnvFile(targetDir, envVars);
 }
 async function mergePackageJson(targetDir, config) {
-    const pkgPath = path_1.default.join(targetDir, 'package.json');
+    const pkgPath = path_1.default.join(targetDir, "package.json");
     if (!(await fs_extra_1.default.pathExists(pkgPath))) {
         return;
     }
@@ -333,19 +386,19 @@ 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 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';
+        .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 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');
+            const newContent = newVars.map((key) => `${key}="${envVars[key]}"`).join("\n");
+            await fs_extra_1.default.appendFile(envExamplePath, "\n" + newContent + "\n");
         }
     }
     else {
@@ -356,79 +409,295 @@ async function mergeEnvFile(targetDir, envVars) {
         await fs_extra_1.default.writeFile(envPath, envContent);
     }
 }
-async function convertToJavaScript(targetDir) {
-    // Remove TypeScript config files
-    const tsFiles = ['tsconfig.json', 'next-env.d.ts'];
+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);
         }
     }
-    // Rename .ts(x) files to .js(x)
-    const renameExtensions = async (dir) => {
+    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 renameExtensions(fullPath);
+            if (entry.isDirectory() && entry.name !== "node_modules") {
+                await transpileAllTsFiles(fullPath);
             }
             else if (entry.isFile()) {
-                if (entry.name.endsWith('.ts')) {
-                    await fs_extra_1.default.rename(fullPath, fullPath.replace(/\.ts$/, '.js'));
-                }
-                else if (entry.name.endsWith('.tsx')) {
-                    await fs_extra_1.default.rename(fullPath, fullPath.replace(/\.tsx$/, '.jsx'));
+                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 renameExtensions(targetDir);
-    // Update package.json to remove TypeScript dependencies
-    const packageJsonPath = path_1.default.join(targetDir, 'package.json');
+    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'];
+            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',
+        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;
+        }
     };
-    const command = commands[packageManager];
-    if (!command) {
-        throw new Error(`Unsupported package manager: ${packageManager}`);
+    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',
+        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 --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',
+            stdio: "pipe",
         });
     }
     catch (error) {
-        throw new Error('Git initialization failed');
+        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];
+        }
     }
+    return output;
 }
 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.bold("Next steps:"));
     console.log(chalk_1.default.cyan(`  cd ${config.projectName}`));
-    console.log(chalk_1.default.cyan(`  ${config.packageManager}${config.packageManager === 'npm' ? ' run' : ''} dev\n`));
+    // Only `bun` is supported as the package manager in production-ready CLI
+    console.log(chalk_1.default.cyan("  bun run dev\n"));
 }