lucy-cli 2.0.0-alpha.9 → 2.0.0-beta.2

package/src/index.ts

@@ -1,36 +1,111 @@
 #!/usr/bin/env node
-import { Chunk, Duration, Effect, pipe, Schedule, Array, Ref } from "effect";
+import { Effect, pipe} from "effect";
 import { build_runtime } from "./runtime.js";
 import { get_args } from "./args.js";
 import 'dotenv/config'
 import { Config } from "./config.js";
-import { ServiceInspectState } from "./states.js";
-import { init } from "./init.js";
+import { init } from "./init/index.js";
+import { logger } from "./utils/logger.js";
+import { open } from "./commands/exec.js";
+import { tasks } from "./tasks/index.js";
+import { cleanupWatchers, killAllProcesses } from "./helpers.js";
+import { wix_sync } from "./wix-sync/index.js";
+import { wix_sdk } from "./wix-sdk/index.js";
 
+let exitReason: 'SIGINT' | 'SIGTERM' | 'none' = 'none'
+let needsCleanup = false;
+
+export function setNeedsCleanup(value: boolean) {
+    needsCleanup = value;
+}
+process.on('exit', (code) => {
+    if(!needsCleanup) return;
+    if(exitReason === 'none') {
+	    killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+        killAllProcesses('wix:dev');   
+        cleanupWatchers();
+    }
+
+    logger.info(`🛑 Process exited with code: ${code}`);
+});
+
+process.on('SIGINT', () => {
+    exitReason = "SIGINT";
+
+	logger.info(`🐕 Received Ctrl+C (SIGINT), cleaning up...`);
+	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+	killAllProcesses('wix:dev');  
+    cleanupWatchers();
+    process.exit(); // Exit explicitly after handling
+});
+
+process.on('SIGTERM', () => {
+    exitReason = "SIGTERM";
+
+	logger.info(`🛑 Received termination signal (SIGTERM), cleaning up...`);
+	killAllProcesses('@wix/cli/bin/wix.cjs'); // Matches processes running the Wix CLI
+	killAllProcesses('wix:dev');  
+    cleanupWatchers();
+    process.exit(); // Exit explicitly after handling
+});
 
 const lucyCLI = pipe(
     Effect.gen(function* (_) {
         const config = yield* Config; 
-        config.config.action.type;
-        if (config.config.action.type === undefined) {
-            return yield* Effect.fail("No Params Provided");
-        }
         if (config.config.action.action === 'init') {
-            return yield* init();
+            return yield* init;
+        }
+        if (config.config.action.action === 'open') {
+            return yield* open;
+        }
+        if (config.config.action.action === 'task') {
+            return yield* tasks;
+        }
+        if (config.config.action.action === 'wix-sync') {
+            return yield* wix_sync;
+        }
+        if (config.config.action.action === 'wix-sdk') {
+            return yield* wix_sdk;
         }
-
-
     }),
+).pipe(
+    Effect.catchTags({
+        BadArgument: (error) => {
+            logger.error(JSON.stringify(error, null, 2));
+            return Effect.fail(new Error(error.message));
+        },
+        ParseError: (error) => {
+            logger.error("Failed to parse:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("Failed to parse: " + error.message));
+        },
+        SystemError: (error) => {
+            logger.error("System error:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("System error: " + error.message));
+        },   
+        AppError: (error) => {
+            logger.error("Application error:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("Application error: " + error.message));
+        }
+    })
 )
 
 async function main() {
     const args = await get_args();
     const runtime= build_runtime(args);
     // The runtime will handle logging failures. This will catch unhandled defects.
-    await runtime.runPromise(lucyCLI)
+    const program = Effect.orDieWith(
+        lucyCLI,
+        (error) => new Error(`The application failed to run: ${error}`
+        )
+)
+    await runtime.runPromise(program)
 }
 
-main().catch((error) => {
-    console.error("An unexpected application error occurred:", error);
+main().then(() => {
+    process.exit(0);
+}).catch((error) => {
+    if (error instanceof Error) {
+        logger.error(error.message);
+    }
     process.exit(1);
 });

package/src/init/blocks.ts

@@ -0,0 +1,85 @@
+import { Effect, Schema } from "effect/index"
+import { Config, lucyJsonName } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { JsonSchema } from "../schemas/index.js";
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { execCommand, openVSCode } from "../commands/exec.js";
+import { approveBuilds, installPackages } from "../commands/install.js";
+import { AppError } from "../error.js";
+import { cleanup } from "../commands/cleanup.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_blocks = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Blocks project...");
+
+        const configJsonRaw = yield* fs.readFile("wix.config.json").pipe(Effect.catchAll((error) => {
+            return Effect.succeed('{}');
+        }))
+        const configJson = Schema.decodeUnknownSync(JsonSchema)(configJsonRaw.toString()) as any;
+        const blocksAppReady = configJson.appId ? true : false;
+
+        yield* checkForDirty();
+
+        if(!blocksAppReady) {
+            const initBlocks = Command.make("npm", "create", "@wix/app@latest", config.config.projectName).pipe(
+                Command.stdin("inherit"),
+                Command.stdout("inherit"),
+                Command.stderr("inherit"),
+                Command.exitCode
+            )
+            if((yield* initBlocks) !== 0) {
+                yield* Effect.fail(new AppError({ message: "Failed to initialize Blocks project. Please check the error message above.", cause: new Error("Failed to initialize Blocks project") }));
+            }
+            const files = yield * fs.readDirectory(config.config.cwd, { recursive: false });
+
+            const allExcludes = ['.git', lucyJsonName];
+            const filteredFiles = files.filter(file => !allExcludes.includes(file));
+
+            const t = yield* fs.stat(filteredFiles[0]);
+            t.type === 'Directory'
+
+            const directories = yield* Effect.filter(
+                filteredFiles,
+                (file) => Effect.gen(function*() {
+                    const fullPath = path.join(config.config.cwd, file);
+                    const stat = yield* fs.stat(fullPath);
+                    return stat.type === "Directory";
+                })
+            );
+            const tempPath = directories[0];
+
+            const projectFiles = yield* fs.readDirectory(directories[0])
+            yield* Effect.forEach(
+                projectFiles.filter(file => file !== '.git'),
+                (file) => fs.copy(path.join(tempPath, file), path.join(config.config.cwd, file), { overwrite: true }),
+                { discard: true }
+            )
+            yield* fs.remove(tempPath, { recursive: true })
+        }
+
+        yield* readPackageJson;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* copyTemplateFiles;
+        yield* execCommand;
+        yield* installPackages();
+        yield* approveBuilds;
+        yield* cleanup;
+        yield* setInitialized;
+
+        logger.success("Blocks project initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/init/cargo.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { writeLucySettings } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+import { setInitialized } from "../commands/edit.js";
+import { openVSCode } from "../commands/exec.js";
+
+export const init_cargo = () => {
+    return Effect.gen(function*() {
+        logger.action("Initializing Cargo project...");
+
+        yield* checkForDirty();
+
+        yield* copyTemplateFiles;
+        yield* writeLucySettings;
+        yield* gitInit();
+        yield* setInitialized;
+        
+        logger.success("Cargo project initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/init/expo.ts

@@ -0,0 +1,69 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { JsonSchema } from "../schemas/index.js";
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { execCommand, openVSCode } from "../commands/exec.js";
+import { approveBuilds, installPackages } from "../commands/install.js";
+import { AppError } from "../error.js";
+import { cleanup } from "../commands/cleanup.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_expo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Expo project...");
+
+        const appJsonRaw = yield* fs.readFile("app.json").pipe(Effect.catchAll((error) => {
+            return Effect.succeed('{}');
+        }))
+        const appJSON = Schema.decodeUnknownSync(JsonSchema)(appJsonRaw.toString()) as any;
+        const expoAppReady = appJSON.expo ? true : false;
+
+        yield* checkForDirty();
+
+        if(!expoAppReady) {
+            const initExpo = Command.make("npx", "create-expo-app@latest", config.config.projectName, "--template", "blank-typescript", "--no-install").pipe(
+                Command.stdout("inherit"),
+                Command.stderr("inherit"),
+                Command.exitCode
+            )
+            if((yield* initExpo) !== 0) {
+                yield* Effect.fail(new AppError({ message: "Failed to initialize Expo project. Please check the error message above.", cause: new Error("Failed to initialize Expo project") }));
+            }
+
+            const tempPath = path.join(config.config.cwd, config.config.projectName)
+
+            const projectFiles = yield* fs.readDirectory(tempPath)
+            yield* Effect.forEach(
+                projectFiles.filter(file => file !== '.git'),
+                (file) => fs.copy(path.join(tempPath, file), path.join(config.config.cwd, file), { overwrite: true }),
+                { discard: true }
+            )
+            yield* fs.remove(tempPath, { recursive: true })
+        }
+
+        yield* readPackageJson;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* copyTemplateFiles;
+        yield* execCommand;
+        yield* installPackages();
+        yield* approveBuilds;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Expo project initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/init/gitModules.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { setInitialized } from "../commands/edit.js";
+import { gitInit } from "../commands/git.js";
+
+export const init_submodules = () => {
+    return Effect.gen(function*() {
+        logger.action("Initializing Git submodules project...");
+
+        yield* gitInit(true);
+        yield* setInitialized;
+        
+        logger.success("GIT initialized successfully!");
+    })
+}

package/src/init/index.ts

@@ -0,0 +1,81 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { init_expo } from "./expo.js";
+import { selectTemplate } from "./templates.js";
+import Enquirer from "enquirer";
+import { AppError } from "../error.js";
+import { createLucyHome } from "../commands/home.js";
+import { readLucyJsonFromTemplate } from "../commands/read.js";
+import { init_monorepo } from "./monorepo.js";
+import { init_cargo } from "./cargo.js";
+import { init_blocks } from "./blocks.js";
+import { init_velo } from "./velo.js";
+import { init_submodules } from "./gitModules.js";
+import { init_tauri } from "./tauri.js";
+import { pkgManagers } from "../schemas/lucy.js";
+
+
+export const init = Effect.gen(function* (_) {
+    const config = yield* Config;
+    if(config.config.action.initType === undefined) {
+        return yield* Effect.fail(new AppError({ message: "No init type provided", cause: new Error("No init type provided") }));
+    }
+    yield* createLucyHome();
+    const projectName = config.config.cwd.split('/').pop() || 'expo-project';
+    const templateQuestion = new Enquirer();
+    const choice = yield* Effect.tryPromise({
+        try: () => templateQuestion.prompt({
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter a project name',
+            initial: projectName,
+            validate: (value: string) => value.trim() !== '' ? true : 'Project name cannot be empty'
+        }),
+        catch: (e) => {
+            return new AppError({ cause: e, message: 'Error selecting template' });
+        }
+    })
+    const selectedName = yield* Schema.decodeUnknown(Schema.Struct({ projectName: Schema.String }))(choice)
+    config.config.projectName = selectedName.projectName.trim();
+    yield* selectTemplate();
+    yield* readLucyJsonFromTemplate;
+
+    const pkgMgrQuestion = new Enquirer();
+    const pkgMgr = yield* Effect.tryPromise({
+        try: () => pkgMgrQuestion.prompt({
+            type: 'select',
+            name: 'packageManager',
+            message: 'Select a package manager',
+            choices: [...pkgManagers],
+        }),
+        catch: (e) => {
+            return new AppError({ cause: e, message: 'Error selecting package manager' });
+        }
+    })
+    const selectedPkgMgr = yield* Schema.decodeUnknown(Schema.Struct({ packageManager: Schema.Literal(...pkgManagers) }))(pkgMgr)
+    config.config.lucySettings.packageManager = selectedPkgMgr.packageManager;
+    
+
+    if(config.config.action.initType === 'expo') {
+        return yield* init_expo();
+    }
+    if(config.config.action.initType === 'monorepo') {
+        return yield* init_monorepo();
+    }
+    if(config.config.action.initType === 'cargo') {
+        return yield* init_cargo();
+    }
+    if(config.config.action.initType === 'blocks') {
+        return yield* init_blocks();
+    }
+    if(config.config.action.initType === 'tauri') {
+        return yield* init_tauri();
+    }
+    if(config.config.action.initType === 'velo') {
+        return yield* init_velo();
+    }
+    if(config.config.action.initType === 'submodules') {
+        return yield* init_submodules();
+    }
+    yield* Effect.fail(new AppError({ message: `Unsupported init type: ${config.config.action.initType}`, cause: new Error(`Unsupported init type: ${config.config.action.initType}`) }));
+})

package/src/init/monorepo.ts

@@ -0,0 +1,72 @@
+import { Effect } from "effect/index"
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized, setProjectName, stringReplace } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { approveBuilds, installPackages, runInstall } from "../commands/install.js";
+import { cleanup } from "../commands/cleanup.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+import { openVSCode } from "../commands/exec.js";
+
+export const init_monorepo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+
+        logger.action("Initializing monorepo...");
+
+        yield* checkForDirty();
+
+        const createMonoRepo = Command.make(
+            "npx", 
+            "-y",
+            "create-nx-workspace", 
+            config.config.projectName,
+            `--appName=${config.config.projectName}`,
+            `--pm=${config.config.lucySettings.packageManager}`, 
+            "--preset=ts", 
+            "--g=true",
+            "--e2eTestRunner=cypress",
+            "--formatter=prettier"
+            ).pipe(
+            Command.stdout("inherit"), // Stream stdout to process.stdout
+            Command.stderr("inherit"), // Stream stderr to process.stderr
+            Command.exitCode // Get the exit code
+        )
+
+        yield* createMonoRepo;
+        
+        const tempPath = path.join(config.config.cwd, config.config.projectName)
+        const projectFiles = yield* fs.readDirectory(tempPath)
+        yield* Effect.forEach(
+            projectFiles.filter(file => file !== '.git'),
+            (file) => fs.copy(path.join(tempPath, file), path.join(config.config.cwd, file), { overwrite: true }),
+            { discard: true }
+        )
+        yield* fs.remove(tempPath, { recursive: true })
+
+        yield* copyTemplateFiles;
+        yield* stringReplace(path.join(config.config.cwd, 'currents.config.ts'), ['__ProjectName__'], [config.config.projectName]);
+        yield* readPackageJson;
+        yield* setProjectName;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* gitInit();
+        yield* runInstall;
+        yield* installPackages(true);
+        yield* approveBuilds;
+        yield* cleanup;
+        yield* setInitialized;
+
+        logger.success("Monorepo initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/init/prepareVelo.ts

@@ -0,0 +1,19 @@
+import { Effect } from 'effect/index';
+import { logger } from '../utils/logger.js';
+import { checkForVelo } from '../commands/checks.js';
+import { gitInit } from '../commands/git.js';
+import { installVeloPackages, runInstall } from '../commands/install.js';
+import { setInitialized } from '../commands/edit.js';
+
+export const prepareVelo = Effect.gen(function*() {
+	logger.action("Initializing Tauri project...");
+	yield* checkForVelo();
+
+	yield* gitInit(true);
+	yield* installVeloPackages
+	yield* runInstall
+	yield* setInitialized;
+	
+    logger.success("Velo Prepared initialized successfully!");
+
+})

package/src/init/tauri.ts

@@ -0,0 +1,42 @@
+import { Effect, Schema } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { writeLucySettings } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+import { setInitialized } from "../commands/edit.js";
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { AppError } from "../error.js";
+import { approveBuilds, installPackages } from "../commands/install.js";
+import { openVSCode } from "../commands/exec.js";
+
+export const init_tauri = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        logger.action("Initializing Tauri project...");
+
+        yield* checkForDirty();
+
+        const initTauri = Command.make("yarn", "create", "tauri-app", config.config.projectName).pipe(
+            Command.stdin("inherit"),
+            Command.stdout("inherit"),
+            Command.stderr("inherit"),
+            Command.runInShell(true),
+            Command.exitCode
+        )
+        if((yield* initTauri) !== 0) {
+            yield* Effect.fail(new AppError({ message: "Failed to initialize Tauri project. Please check the error message above.", cause: new Error("Failed to initialize Tauri project") }));
+        }
+        yield* copyTemplateFiles;
+        yield* installPackages();
+        yield* approveBuilds;
+        yield* writeLucySettings;
+        yield* gitInit();
+        yield* setInitialized;
+
+        logger.success("Tauri project initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/init/templates.ts

@@ -0,0 +1,98 @@
+import { Effect, Schema } from "effect/index";
+import { Config, lucyJsonName, lucyJsonPath } from "../config.js";
+import { orange, red, green, logger } from "../utils/logger.js";
+import { FileSystem } from "@effect/platform"
+import path, { join } from 'path';
+import fsp from 'fs/promises';
+import Enquirer from 'enquirer';
+import { AppError } from "../error.js";
+import { lucySettings } from "../schemas/lucy.js";
+import { JsonSchema } from "../schemas/index.js";
+
+export const selectTemplate = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config
+        const fs = yield* FileSystem.FileSystem;
+        const templatesPath = join(config.config.lucyHome, 'templates');
+        const files = yield* Effect.tryPromise({
+            try: () => fsp.readdir(templatesPath, { withFileTypes: true }),
+            catch: (e) => {
+                console.log((`💩 ${red.underline.bold("=> Templates folder not found at =>")} ${orange(templatesPath)}`));
+                return new AppError({ cause: e, message: 'Templates folder not found' });
+            }
+        })
+                    
+        const templateChoices: string[] = [];
+        for (const dirent of files) {
+            if (dirent.isDirectory()) {
+                const lucyRaw = yield* fs.readFileString(join(templatesPath, dirent.name, lucyJsonName));   
+                const lucySettingsJSON = yield* Schema.decodeUnknown(JsonSchema)(lucyRaw); 
+                const lucySetting = yield* Schema.decodeUnknown(lucySettings)(lucySettingsJSON)
+                if (lucySetting.type === config.config.action.initType) {
+                    templateChoices.push(dirent.name);
+                }
+            }
+        }
+
+        if (templateChoices.length === 0) {
+            console.log((`💩 ${red.underline.bold("=> No templates found in =>")} ${orange(templatesPath)}`));
+            return;
+        } 
+
+        const templateQuestion = new Enquirer();
+        const choice = yield* Effect.tryPromise({
+            try: () => templateQuestion.prompt({
+                type: 'select',
+                name: 'template',
+                message: 'Select a project template',
+                choices: templateChoices
+            }),
+            catch: (e) => {
+                return new AppError({ cause: e, message: 'Error selecting template' });
+            }
+        })
+
+    const selectedTemplate = yield* Schema.decodeUnknown(Schema.Struct({ template: Schema.String }))(choice)
+    const templateDir = join(templatesPath, selectedTemplate.template );
+    const templateFilesDir = join(templateDir, 'files');
+    config.config.templateDir = templateDir;
+    config.config.templateFiles = templateFilesDir;
+
+    const templateSettingsPath = join(templateDir, lucyJsonName);
+
+    if (!(yield* fs.exists(templateSettingsPath))) {
+        logger.warning((`💩 ${red.underline.bold(`Template is missing ${lucyJsonName} at =>`)} ${orange(templateSettingsPath)}`));
+        yield* Effect.fail(new AppError({ message: `Template is missing ${lucyJsonName}`, cause: templateSettingsPath }));
+    }
+    const lucySettingsRaw = yield* fs.readFileString(templateSettingsPath);
+    const newLucySettings = yield* Schema.decodeUnknown(lucySettings)(JSON.parse(lucySettingsRaw));
+    if( newLucySettings.type !== config.config.action.initType) return yield* Effect.fail(new AppError({
+        message: `Template type ${newLucySettings.type} does not match action type ${config.config.action.initType}`,
+        cause: newLucySettings.type
+    }));
+    if(config.config.lucySettings.initialized) {
+        const overwriteQuestion = new Enquirer();
+
+        const overwrite = yield* Effect.tryPromise({
+            try: () => overwriteQuestion.prompt({
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Overwrite existing ${lucyJsonName} settings?`,
+            }),
+            catch: (e) => {
+                return new AppError({
+                    cause: e,
+                    message: "Error overwriting settings",
+                });
+            }
+        })
+        const choice = yield* Schema.decodeUnknown(Schema.Struct({ overwrite: Schema.Boolean }))(overwrite);
+        if (choice.overwrite) {
+            config.config.lucySettings = newLucySettings;
+        } else {
+            logger.info(`Existing ${lucyJsonName} settings will be used.`);
+        }
+    }
+    logger.success(`Selected template: ${green(selectedTemplate.template)}`);
+    });
+}