create-zephyr-apps 0.0.6 → 0.0.8

package/dist/index.mjs

@@ -1,33 +1,11 @@
 #!/usr/bin/env node
-import * as __WEBPACK_EXTERNAL_MODULE_node_timers_promises_aedbf14c__ from "node:timers/promises";
 import * as __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__ from "node:child_process";
-import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
-import * as __WEBPACK_EXTERNAL_MODULE_child_process__ from "child_process";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_timers_promises_aedbf14c__ from "node:timers/promises";
 import * as __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__ from "@clack/prompts";
+import * as __WEBPACK_EXTERNAL_MODULE_chalk__ from "chalk";
 import * as __WEBPACK_EXTERNAL_MODULE_tempy__ from "tempy";
-import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
-function end_note({ project }) {
-    try {
-        (0, __WEBPACK_EXTERNAL_MODULE_child_process__.exec)(`${project.path} && git config user.name`, (err, stdout, stderr)=>{
-            console.log(stdout);
-            const user_name = stdout.toString().trim();
-            const repo_name = project.path.split('/').pop();
-            let next_steps;
-            next_steps = 'web' === project.type ? `cd ${repo_name}        \npnpm install\nrm -rf .git\ngit remote add origin https://github.com/${user_name.length >= 1 ? user_name : 'YourUsername'}/${repo_name}.git\npnpm run build` : `cd ${repo_name}        \npnpm install\nrm -rf .git\npnpm run build\nMake your first commit and link it to the remote repository!`;
-            (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note)(next_steps, 'Next steps.');
-        });
-    } catch (error) {
-        console.error(error);
-    } finally{
-        const end_notes = [
-            `Discord: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://zephyr-cloud.io/discord'))}`,
-            `Documentation: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://zephyr-cloud.io/docs'))}`,
-            `Open an issue: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://github.com/ZephyrCloudIO/create-zephyr-apps/issues'))}`
-        ];
-        (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note)(Object.values(end_notes).join('\n'), 'Problems?');
-    }
-}
 const TEMPLATES = {
     'rspack-project': {
         label: 'React + Rspack',
@@ -85,6 +63,69 @@ const TEMPLATES = {
         framework: 'react'
     }
 };
+function end_note({ project }) {
+    try {
+        (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.exec)('git config user.name', (err, stdout, stderr)=>{
+            const user_name = stdout.toString().trim();
+            const repo_name = project.path.split('/').pop();
+            let next_steps;
+            next_steps = 'web' === project.type ? [
+                `cd ${repo_name}`,
+                'pnpm install',
+                'pnpm run build'
+            ] : [
+                `cd ${repo_name}`,
+                'pnpm install',
+                __WEBPACK_EXTERNAL_MODULE_chalk__["default"].magenta(`git remote add origin https://github.com/${user_name.length >= 1 ? user_name : 'YourUsername'}/${repo_name}.git`),
+                'ZC=1 pnpm run start',
+                '\n--------------------------------\n',
+                'Make sure to commit and add a remote to the remote repository!',
+                `Read more about how Module Federation works with Zephyr: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://docs.zephyr-cloud.io/how-to/mf-guide'))}`
+            ];
+            (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note)(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(next_steps.join('\n')), 'Next steps.');
+        });
+    } catch (error) {
+        console.error(error);
+    } finally{
+        const end_notes = [
+            `Discord: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://zephyr-cloud.io/discord'))}`,
+            `Documentation: ${'web' === project.type ? __WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://docs.zephyr-cloud.io/recipes')) : __WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://docs.zephyr-cloud.io/recipes/repack-mf'))}`,
+            `Open an issue: ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan('https://github.com/ZephyrCloudIO/create-zephyr-apps/issues'))}`
+        ];
+        (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note)(Object.values(end_notes).join('\n'), 'Problems?');
+    }
+}
+function runCmd(cmd, cwd) {
+    return new Promise((resolve, reject)=>{
+        (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.exec)(cmd, {
+            cwd
+        }, (err, stdout, stderr)=>{
+            if (err) {
+                console.error(`Error executing command: ${cmd}`, err);
+                reject(err);
+            } else resolve();
+        });
+    });
+}
+async function initializeGit(projectPath) {
+    const shouldInit = await (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm)({
+        message: 'Would you like to initialize a new Git repository?',
+        initialValue: true
+    });
+    if ((0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel)(shouldInit)) {
+        (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.cancel)('Operation cancelled');
+        process.exit(0);
+    }
+    if (shouldInit) {
+        await runCmd('git init', projectPath);
+        await runCmd('git config user.email "zephyrbot@zephyr-cloud.io"', projectPath);
+        await runCmd('git config user.name "Zephyr Bot"', projectPath);
+        await runCmd('git add .', projectPath);
+        await runCmd('git commit -m "Initial commit from Zephyr"', projectPath);
+        await runCmd('git config --unset user.email', projectPath);
+        await runCmd('git config --unset user.name', projectPath);
+    }
+}
 async function main() {
     console.clear();
     await (0, __WEBPACK_EXTERNAL_MODULE_node_timers_promises_aedbf14c__.setTimeout)(1000);
@@ -113,12 +154,13 @@ async function main() {
                 options: [
                     {
                         value: 'web',
-                        label: 'Web'
+                        label: 'Web',
+                        hint: 'You will be choosing from a selection of templates provided by us.'
                     },
                     {
                         value: 'react-native',
                         label: 'React Native',
-                        hint: 'You will be building React Native powered by Re.Pack.'
+                        hint: 'This is a comprehensive example project provided by us. You will be building React Native powered by Re.Pack.'
                     }
                 ]
             }),
@@ -146,64 +188,68 @@ async function main() {
     const project_path = project.path.replace('./', '').trim();
     const s = (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner)();
     s.start(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].cyan(`Creating project in ${project_path}`));
-    if ('web' === project.type) (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.exec)(command_web, async (err, stdout, stderr)=>{
-        if (err) {
-            s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error cloning ${command_web} to ${project_path}...`)));
-            console.error(err);
-            process.exit(0);
-        }
-        if (!err) {
-            const outputPath = __WEBPACK_EXTERNAL_MODULE_path__["default"].join(process.cwd(), project.path);
-            const clonedPath = __WEBPACK_EXTERNAL_MODULE_path__["default"].join(temp_dir, 'examples', project.templates);
-            try {
-                await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.cp(clonedPath, outputPath, {
-                    recursive: true,
-                    force: true
-                });
-                s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`Project successfully created at ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(project_path)}`));
-            } catch (error) {
-                console.error(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error cloning to ${project_path}...`)));
-                console.error(error);
-                process.exit(2);
-            } finally{
-                await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.rm(temp_dir, {
-                    recursive: true,
-                    force: true
-                });
-                end_note({
-                    project
-                });
-            }
-        }
-    });
-    if ('react-native' === project.type) (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.exec)(command_react_native, async (err, stdout, stderr)=>{
-        if (err) {
-            s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error cloning to ${project_path}...`)));
-            console.error(err);
-            process.exit(2);
-        }
-        if (!err) {
-            const outputPath = __WEBPACK_EXTERNAL_MODULE_path__["default"].join(process.cwd(), project.path);
-            try {
-                await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.cp(temp_dir, outputPath, {
-                    recursive: true,
-                    force: true
-                });
-                s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`Project successfully created at ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(project_path)}`));
-            } catch (error) {
-                s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error clonin to ${project_path}`)));
-                console.error(error);
-                process.exit(2);
-            } finally{
-                await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.rm(temp_dir, {
-                    recursive: true,
-                    force: true
-                });
-                end_note({
-                    project
-                });
-            }
-        }
-    });
+    const outputPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), project.path);
+    try {
+        if ('web' === project.type) await new Promise((resolve, reject)=>{
+            (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.exec)(command_web, async (err)=>{
+                if (err) {
+                    s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error cloning repository to ${project_path}...`)));
+                    return reject(err);
+                }
+                const clonedPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(temp_dir, 'examples', project.templates);
+                try {
+                    await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.rm(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(clonedPath, '.git'), {
+                        recursive: true,
+                        force: true
+                    });
+                    await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.cp(clonedPath, outputPath, {
+                        recursive: true,
+                        force: true
+                    });
+                    s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`Project successfully created at ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(project_path)}`));
+                    resolve();
+                } catch (copyErr) {
+                    s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error copying template to ${project_path}...`)));
+                    reject(copyErr);
+                }
+            });
+        });
+        else if ('react-native' === project.type) await new Promise((resolve, reject)=>{
+            (0, __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__.exec)(command_react_native, async (err)=>{
+                if (err) {
+                    s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error cloning repository to ${project_path}...`)));
+                    return reject(err);
+                }
+                try {
+                    await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.rm(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(temp_dir, '.git'), {
+                        recursive: true,
+                        force: true
+                    });
+                    await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.cp(temp_dir, outputPath, {
+                        recursive: true,
+                        force: true
+                    });
+                    s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].green(`Project successfully created at ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].underline(project_path)}`));
+                    resolve();
+                } catch (copyErr) {
+                    s.stop(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bgRed(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].black(`Error copying files to ${project_path}...`)));
+                    reject(copyErr);
+                }
+            });
+        });
+        await initializeGit(outputPath);
+        (0, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.note)('Git repository and initial commit created successfully!');
+    } catch (error) {
+        console.error(error);
+        process.exit(2);
+    } finally{
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.promises.rm(temp_dir, {
+            recursive: true,
+            force: true
+        });
+        end_note({
+            project
+        });
+    }
 }
 main().catch(console.error);

package/dist/package/utils/constants.d.ts

@@ -60,4 +60,4 @@ declare const TEMPLATES: {
         framework: string;
     };
 };
-export { REPO_OWNER, REPO_NAME, REPACK_REPO, BASE_REPO, REPACK_REPO_PATH, TEMPLATES };
+export { REPO_OWNER, REPO_NAME, REPACK_REPO, BASE_REPO, REPACK_REPO_PATH, TEMPLATES, };

package/dist/package/utils/end.d.ts

@@ -1,4 +1,4 @@
-import { CLIOptions } from './types';
+import type { CLIOptions } from './types';
 export default function end_note({ project }: {
     project: CLIOptions;
 }): void;

package/package/index.ts

@@ -1,31 +1,79 @@
 #!/usr/bin/env node
-import { setTimeout } from 'node:timers/promises';
 import { exec } from 'node:child_process';
-import end_note from './utils/end'
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { setTimeout } from 'node:timers/promises';
 import {
-  spinner,
+  cancel,
+  confirm,
   group,
   intro,
-  outro,
   isCancel,
-  password,
-  cancel,
-  text,
   note,
-  confirm,
   select,
-  multiselect,
-  tasks,
-  log,
+  spinner,
+  text,
   updateSettings,
 } from '@clack/prompts';
-import c from "chalk";
-import { TEMPLATES } from './utils/constants';
-import { CLIOptions } from './utils/types';
+import c from 'chalk';
 import * as tempy from 'tempy';
-import path from 'path';
-import * as fs from 'node:fs'
+import { TEMPLATES } from './utils/constants';
+import end_note from './utils/end';
+import type { CLIOptions } from './utils/types';
+
+/**
+ * Helper function to execute a command in the given working directory.
+ */
+function runCmd(cmd: string, cwd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    exec(cmd, { cwd }, (err, stdout, stderr) => {
+      if (err) {
+        console.error(`Error executing command: ${cmd}`, err);
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
 
+/**
+ * Initialize Git in the project directory, set temporary user configuration,
+ * commit the changes, and then remove the local configuration.
+ */
+async function initializeGit(projectPath: string): Promise<void> {
+  // Ask the user if they want to initialize a Git repository.
+  const shouldInit = await confirm({
+    message: 'Would you like to initialize a new Git repository?',
+    initialValue: true,
+  });
+
+  if (isCancel(shouldInit)) {
+    cancel('Operation cancelled');
+    process.exit(0);
+  }
+
+  if (shouldInit) {
+    // Initialize the repository.
+    await runCmd('git init', projectPath);
+
+    // Set temporary Git user configuration.
+    await runCmd(
+      'git config user.email "zephyrbot@zephyr-cloud.io"',
+      projectPath,
+    );
+    await runCmd('git config user.name "Zephyr Bot"', projectPath);
+
+    // Stage all files and commit them.
+    await runCmd('git add .', projectPath);
+    await runCmd('git commit -m "Initial commit from Zephyr"', projectPath);
+
+    // Remove the temporary local Git configuration so that the user's global
+    // settings will be used for future commits.
+    await runCmd('git config --unset user.email', projectPath);
+    await runCmd('git config --unset user.name', projectPath);
+  }
+}
 
 async function main() {
   console.clear();
@@ -44,7 +92,7 @@ async function main() {
   note('npx create-zephyr-apps@latest');
   intro(`${c.bgCyan(c.black(' Create federated applications with Zephyr '))}`);
 
-  const project = await group(
+  const project = (await group(
     {
       path: ({ results }) => {
         return text({
@@ -65,33 +113,32 @@ async function main() {
             {
               value: 'web',
               label: 'Web',
+              hint: 'You will be choosing from a selection of templates provided by us.',
             },
             {
               value: 'react-native',
               label: 'React Native',
-              hint: 'You will be building React Native powered by Re.Pack.',
+              hint: 'This is a comprehensive example project provided by us. You will be building React Native powered by Re.Pack.',
             },
           ],
         }),
 
       templates: ({ results }) => {
-
         if (results.type === 'web') {
           return select({
             message: 'Pick a template: ',
             initialValue: 'react-rspack-mf',
             maxItems: 5,
-            options: Object.keys(TEMPLATES).map((template) => {
-              return {
-                value: template as keyof typeof TEMPLATES,
-                label: c.cyan(TEMPLATES[template as keyof typeof TEMPLATES].label),
-                hint: TEMPLATES[template as keyof typeof TEMPLATES].hint
-              }
-            })
-          })
+            options: Object.keys(TEMPLATES).map(template => ({
+              value: template as keyof typeof TEMPLATES,
+              label: c.cyan(
+                TEMPLATES[template as keyof typeof TEMPLATES].label,
+              ),
+              hint: TEMPLATES[template as keyof typeof TEMPLATES].hint,
+            })),
+          });
         }
       },
-
     },
     {
       onCancel: () => {
@@ -99,92 +146,110 @@ async function main() {
         process.exit(0);
       },
     },
-  ) as CLIOptions;
-
-
-
-  const temp_dir = tempy.temporaryDirectory()
-
-  const command_web = `git clone --depth 1 https://github.com/ZephyrCloudIO/zephyr-examples.git -b main ${temp_dir}`
-  const command_react_native = `git clone --depth 1 https://github.com/ZephyrCloudIO/zephyr-repack-example.git -b main ${temp_dir}`
-
-  const project_path = project.path.replace('./', '').trim()
-
-  const s = spinner()
-  s.start(c.cyan(`Creating project in ${project_path}`))
-  if (project.type === 'web') {
-
-
-    exec(command_web, async (err, stdout, stderr) => {
-
-      if (err) {
-        s.stop(c.bgRed(c.black(`Error cloning ${command_web} to ${project_path}...`)))
-        console.error(err);
-        process.exit(0);
-
-      }
-
-      if (!err) {
-        const outputPath = path.join(process.cwd(), project.path);
-
-        const clonedPath = path.join(temp_dir, 'examples', project.templates as string)
-
-        try {
-          const result2 = await fs.promises.cp(clonedPath, outputPath, {
-            recursive: true,
-            force: true
-          });
-
-          s.stop(c.green(`Project successfully created at ${c.underline(project_path)}`))
-
-        } catch (error) {
-          console.error(c.bgRed(c.black(`Error cloning to ${project_path}...`)))
-          console.error(error)
-          process.exit(2)
-        } finally {
-          await fs.promises.rm(temp_dir, { recursive: true, force: true })
-          end_note({ project })
-        }
-      }
-    })
-
-  }
-
-
-  if (project.type === 'react-native') {
-
-
-    exec(command_react_native, async (err, stdout, stderr) => {
-      if (err) {
-        s.stop(c.bgRed(c.black(`Error cloning to ${project_path}...`)))
-        console.error(err)
-        process.exit(2)
-      }
-
-      if (!err) {
-
-        const outputPath = path.join(process.cwd(), project.path);
-        try {
-          const result2 = await fs.promises.cp(temp_dir, outputPath, {
-            recursive: true,
-            force: true
-          });
-          s.stop(c.green(`Project successfully created at ${c.underline(project_path)}`))
-        } catch (error) {
-          s.stop(c.bgRed(c.black(`Error clonin to ${project_path}`)))
-          console.error(error)
-          process.exit(2)
-        } finally {
-          await fs.promises.rm(temp_dir, { recursive: true, force: true })
-          end_note({ project })
-        }
-
-      }
-    })
+  )) as CLIOptions;
+
+  const temp_dir = tempy.temporaryDirectory();
+  const command_web = `git clone --depth 1 https://github.com/ZephyrCloudIO/zephyr-examples.git -b main ${temp_dir}`;
+  const command_react_native = `git clone --depth 1 https://github.com/ZephyrCloudIO/zephyr-repack-example.git -b main ${temp_dir}`;
+
+  const project_path = project.path.replace('./', '').trim();
+  const s = spinner();
+  s.start(c.cyan(`Creating project in ${project_path}`));
+  const outputPath = path.join(process.cwd(), project.path);
+
+  try {
+    if (project.type === 'web') {
+      await new Promise<void>((resolve, reject) => {
+        exec(command_web, async err => {
+          if (err) {
+            s.stop(
+              c.bgRed(
+                c.black(`Error cloning repository to ${project_path}...`),
+              ),
+            );
+            return reject(err);
+          }
+
+          const clonedPath = path.join(
+            temp_dir,
+            'examples',
+            project.templates as string,
+          );
+
+          try {
+            // Remove .git folder from the cloned template
+            await fs.promises.rm(path.join(clonedPath, '.git'), {
+              recursive: true,
+              force: true,
+            });
+
+            await fs.promises.cp(clonedPath, outputPath, {
+              recursive: true,
+              force: true,
+            });
+            s.stop(
+              c.green(
+                `Project successfully created at ${c.underline(project_path)}`,
+              ),
+            );
+            resolve();
+          } catch (copyErr) {
+            s.stop(
+              c.bgRed(c.black(`Error copying template to ${project_path}...`)),
+            );
+            reject(copyErr);
+          }
+        });
+      });
+    } else if (project.type === 'react-native') {
+      await new Promise<void>((resolve, reject) => {
+        exec(command_react_native, async err => {
+          if (err) {
+            s.stop(
+              c.bgRed(
+                c.black(`Error cloning repository to ${project_path}...`),
+              ),
+            );
+            return reject(err);
+          }
+
+          try {
+            // Remove .git folder from the cloned template
+            await fs.promises.rm(path.join(temp_dir, '.git'), {
+              recursive: true,
+              force: true,
+            });
+
+            await fs.promises.cp(temp_dir, outputPath, {
+              recursive: true,
+              force: true,
+            });
+            s.stop(
+              c.green(
+                `Project successfully created at ${c.underline(project_path)}`,
+              ),
+            );
+            resolve();
+          } catch (copyErr) {
+            s.stop(
+              c.bgRed(c.black(`Error copying files to ${project_path}...`)),
+            );
+            reject(copyErr);
+          }
+        });
+      });
+    }
+
+    // Initialize Git only if user confirms
+    await initializeGit(outputPath);
+    note('Git repository and initial commit created successfully!');
+  } catch (error) {
+    console.error(error);
+    process.exit(2);
+  } finally {
+    await fs.promises.rm(temp_dir, { recursive: true, force: true });
+    end_note({ project });
   }
-
-
 }
 
 main().catch(console.error);
-