create-start-app 0.3.0 → 0.4.0

package/README.md

@@ -8,13 +8,14 @@ To help accelerate the migration away from `create-react-app` we created the `cr
 
 To maintain compatability with `create-react-app` you can build a new application by running:
 
-| Command                                                        | Description                 |
-| -------------------------------------------------------------- | --------------------------- |
-| `npx create-tsrouter-app@latest my-app`                        | Create a new app            |
-| `npx create-tsrouter-app@latest my-app --template file-router` | Create a new file based app |
-| `npx create-tsrouter-app@latest my-app --template typescript`  | Create a new TypeScript app |
-| `npx create-tsrouter-app@latest my-app --template javascript`  | Create a new JavaScript app |
-| `npx create-tsrouter-app@latest my-app --tailwind`             | Add Tailwind CSS support    |
+| Command                                                                          | Description                                       |
+| -------------------------------------------------------------------------------- | ------------------------------------------------- |
+| `npx create-tsrouter-app@latest my-app`                                          | Create a new app                                  |
+| `npx create-tsrouter-app@latest my-app --template file-router`                   | Create a new file based app                       |
+| `npx create-tsrouter-app@latest my-app --template typescript`                    | Create a new TypeScript app using the Code Router |
+| `npx create-tsrouter-app@latest my-app --tailwind`                               | Add Tailwind CSS support                          |
+| `npx create-tsrouter-app@latest my-app --framework solid`                        | Create a Solid app                                |
+| `npx create-tsrouter-app@latest my-app --framework solid --template file-router` | Create a Solid app with file-router               |
 
 If you don't specify a project name, the CLI will walk you through an interactive setup process:
 
@@ -43,8 +44,9 @@ Available options:
 
 - `--template <type>`: Choose between `file-router`, `typescript`, or `javascript`
 - `--tailwind`: Enable Tailwind CSS
-- `--package-manager`: Specify your preferred package manager (`npm`, `yarn`, `pnpm`, or `bun`)
+- `--package-manager`: Specify your preferred package manager (`npm`, `yarn`, `pnpm`, `bun`, or `deno`)
 - `--no-git`: Do not initialize a git repository
+- `--add-ons`: Enable add-on selection or specify add-ons to install
 
 When using flags, the CLI will display which options were provided and only prompt for the remaining choices.
 
@@ -88,10 +90,40 @@ Enable Tailwind CSS either through the interactive CLI or by adding the `--tailw
 
 ### Package Manager
 
-Choose your preferred package manager (`npm`, `bun`, `yarn`, or `pnpm`) either through the interactive CLI or using the `--package-manager` flag.
+Choose your preferred package manager (`npm`, `bun`, `yarn`, `pnpm`, or `deno`) either through the interactive CLI or using the `--package-manager` flag.
 
 Extensive documentation on using the TanStack Router, migrating to a File Base Routing approach, as well as integrating [@tanstack/react-query](https://tanstack.com/query/latest) and [@tanstack/store](https://tanstack.com/store/latest) can be found in the generated `README.md` for your project.
 
+## Add-ons (experimental)
+
+You can enable add-on selection:
+
+```bash
+npx create-tsrouter-app@latest --add-ons
+```
+
+This will prompt you to select the add-ons you want to enable during application creation.
+
+You can enable specific add-ons directly by adding a comma separated list of add-on names to the `--add-ons` flag. For example:
+
+```bash
+npx create-tsrouter-app@latest my-app --add-ons shadcn,tanstack-query
+```
+
+You can get a list of all available add-ons by running:
+
+```bash
+npx create-tsrouter-app@latest --list-add-ons
+```
+
+This will display a list of all available add-ons for React that are compatible with the Code Router.
+
+```bash
+npx create-tsrouter-app@latest --list-add-ons --framework solid --template file-router
+```
+
+Will get you a list of all available add-ons for Solid that are compatible with the File Router.
+
 # Contributing
 
 Check out the [Contributing](CONTRIBUTING.md) guide.

package/dist/add-ons.js

@@ -0,0 +1,69 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import { DEFAULT_FRAMEWORK } from './constants.js';
+function isDirectory(path) {
+    return statSync(path).isDirectory();
+}
+export async function getAllAddOns(framework, template) {
+    const addOns = [];
+    for (const type of ['add-on', 'example']) {
+        const addOnsBase = fileURLToPath(new URL(`../templates/${framework}/${type}`, import.meta.url));
+        if (!existsSync(addOnsBase)) {
+            continue;
+        }
+        for (const dir of await readdirSync(addOnsBase).filter((file) => isDirectory(resolve(addOnsBase, file)))) {
+            const filePath = resolve(addOnsBase, dir, 'info.json');
+            const fileContent = await readFile(filePath, 'utf-8');
+            const info = JSON.parse(fileContent);
+            if (!info.templates.includes(template)) {
+                continue;
+            }
+            let packageAdditions = {};
+            if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
+                packageAdditions = JSON.parse(await readFile(resolve(addOnsBase, dir, 'package.json'), 'utf-8'));
+            }
+            let readme;
+            if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
+                readme = await readFile(resolve(addOnsBase, dir, 'README.md'), 'utf-8');
+            }
+            addOns.push({
+                ...info,
+                id: dir,
+                type,
+                directory: resolve(addOnsBase, dir),
+                packageAdditions,
+                readme,
+            });
+        }
+    }
+    return addOns;
+}
+// Turn the list of chosen add-on IDs into a final list of add-ons by resolving dependencies
+export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
+    const finalAddOnIDs = new Set(chosenAddOnIDs);
+    const addOns = await getAllAddOns(framework, template);
+    for (const addOnID of finalAddOnIDs) {
+        const addOn = addOns.find((a) => a.id === addOnID);
+        if (!addOn) {
+            throw new Error(`Add-on ${addOnID} not found`);
+        }
+        for (const dependsOn of addOn.dependsOn || []) {
+            const dep = addOns.find((a) => a.id === dependsOn);
+            if (!dep) {
+                throw new Error(`Dependency ${dependsOn} not found`);
+            }
+            finalAddOnIDs.add(dep.id);
+        }
+    }
+    return [...finalAddOnIDs].map((id) => addOns.find((a) => a.id === id));
+}
+export async function listAddOns(options) {
+    const mode = options.template === 'file-router' ? 'file-router' : 'code-router';
+    const addOns = await getAllAddOns(options.framework || DEFAULT_FRAMEWORK, mode);
+    for (const addOn of addOns) {
+        console.log(`${chalk.bold(addOn.id)}: ${addOn.description}`);
+    }
+}

package/dist/cli.js

@@ -0,0 +1,78 @@
+import { Command, InvalidArgumentError } from 'commander';
+import { intro, log } from '@clack/prompts';
+import { createApp } from './create-app.js';
+import { normalizeOptions, promptForOptions } from './options.js';
+import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager.js';
+import runServer from './mcp.js';
+import { listAddOns } from './add-ons.js';
+import { DEFAULT_FRAMEWORK, SUPPORTED_FRAMEWORKS } from './constants.js';
+export function cli() {
+    const program = new Command();
+    program
+        .name('create-tsrouter-app')
+        .description('CLI to create a new TanStack application')
+        .argument('[project-name]', 'name of the project')
+        .option('--no-git', 'do not create a git repository')
+        .option('--framework <type>', 'project framework (solid, react)', (value) => {
+        if (!SUPPORTED_FRAMEWORKS.includes(value)) {
+            throw new InvalidArgumentError(`Invalid framework: ${value}. Only the following are allowed: ${SUPPORTED_FRAMEWORKS.join(', ')}`);
+        }
+        return value;
+    }, DEFAULT_FRAMEWORK)
+        .option('--template <type>', 'project template (typescript, javascript, file-router)', (value) => {
+        if (value !== 'typescript' &&
+            value !== 'javascript' &&
+            value !== 'file-router') {
+            throw new InvalidArgumentError(`Invalid template: ${value}. Only the following are allowed: typescript, javascript, file-router`);
+        }
+        return value;
+    })
+        .option(`--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`, `Explicitly tell the CLI to use this package manager`, (value) => {
+        if (!SUPPORTED_PACKAGE_MANAGERS.includes(value)) {
+            throw new InvalidArgumentError(`Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
+        }
+        return value;
+    })
+        .option('--tailwind', 'add Tailwind CSS', false)
+        .option('--add-ons [...add-ons]', 'pick from a list of available add-ons (comma separated list)', (value) => {
+        let addOns = !!value;
+        if (typeof value === 'string') {
+            addOns = value.split(',').map((addon) => addon.trim());
+        }
+        return addOns;
+    })
+        .option('--list-add-ons', 'list all available add-ons', false)
+        .option('--mcp', 'run the MCP server', false)
+        .action(async (projectName, options) => {
+        if (options.listAddOns) {
+            await listAddOns(options);
+        }
+        else if (options.mcp) {
+            await runServer();
+        }
+        else {
+            try {
+                const cliOptions = {
+                    projectName,
+                    ...options,
+                };
+                let finalOptions = await normalizeOptions(cliOptions);
+                if (finalOptions) {
+                    intro(`Creating a new TanStack app in ${projectName}...`);
+                }
+                else {
+                    intro("Let's configure your TanStack application");
+                    finalOptions = await promptForOptions(cliOptions);
+                }
+                await createApp(finalOptions);
+            }
+            catch (error) {
+                log.error(error instanceof Error
+                    ? error.message
+                    : 'An unknown error occurred');
+                process.exit(1);
+            }
+        }
+    });
+    program.parse();
+}

package/dist/constants.js

@@ -0,0 +1,4 @@
+export const CODE_ROUTER = 'code-router';
+export const FILE_ROUTER = 'file-router';
+export const SUPPORTED_FRAMEWORKS = ['solid', 'react'];
+export const DEFAULT_FRAMEWORK = 'react';

package/dist/create-app.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+import { appendFile, copyFile, mkdir, readFile, writeFile, } from 'node:fs/promises';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { log, outro, spinner } from '@clack/prompts';
+import { execa } from 'execa';
+import { render } from 'ejs';
+import { format } from 'prettier';
+import chalk from 'chalk';
+import { CODE_ROUTER, FILE_ROUTER } from './constants.js';
+function sortObject(obj) {
+    return Object.keys(obj)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = obj[key];
+        return acc;
+    }, {});
+}
+function createCopyFiles(targetDir) {
+    return async function copyFiles(templateDir, files) {
+        for (const file of files) {
+            const targetFileName = file.replace('.tw', '');
+            await copyFile(resolve(templateDir, file), resolve(targetDir, targetFileName));
+        }
+    };
+}
+function jsSafeName(name) {
+    return name
+        .split(/[^a-zA-Z0-9]/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function createTemplateFile(projectName, options, targetDir) {
+    return async function templateFile(templateDir, file, targetFileName, extraTemplateValues) {
+        const templateValues = {
+            packageManager: options.packageManager,
+            projectName: projectName,
+            typescript: options.typescript,
+            tailwind: options.tailwind,
+            js: options.typescript ? 'ts' : 'js',
+            jsx: options.typescript ? 'tsx' : 'jsx',
+            fileRouter: options.mode === FILE_ROUTER,
+            codeRouter: options.mode === CODE_ROUTER,
+            addOnEnabled: options.chosenAddOns.reduce((acc, addOn) => {
+                acc[addOn.id] = true;
+                return acc;
+            }, {}),
+            addOns: options.chosenAddOns,
+            ...extraTemplateValues,
+        };
+        const template = await readFile(resolve(templateDir, file), 'utf-8');
+        let content = '';
+        try {
+            content = render(template, templateValues);
+        }
+        catch (error) {
+            console.error(chalk.red(`EJS error in file ${file}`));
+            console.error(error);
+            process.exit(1);
+        }
+        const target = targetFileName ?? file.replace('.ejs', '');
+        if (target.endsWith('.ts') || target.endsWith('.tsx')) {
+            content = await format(content, {
+                semi: false,
+                singleQuote: true,
+                trailingComma: 'all',
+                parser: 'typescript',
+            });
+        }
+        await mkdir(dirname(resolve(targetDir, target)), {
+            recursive: true,
+        });
+        await writeFile(resolve(targetDir, target), content);
+    };
+}
+async function createPackageJSON(projectName, options, templateDir, routerDir, targetDir, addOns) {
+    let packageJSON = JSON.parse(await readFile(resolve(templateDir, 'package.json'), 'utf8'));
+    packageJSON.name = projectName;
+    if (options.typescript) {
+        const tsPackageJSON = JSON.parse(await readFile(resolve(templateDir, 'package.ts.json'), 'utf8'));
+        packageJSON = {
+            ...packageJSON,
+            devDependencies: {
+                ...packageJSON.devDependencies,
+                ...tsPackageJSON.devDependencies,
+            },
+        };
+    }
+    if (options.tailwind) {
+        const twPackageJSON = JSON.parse(await readFile(resolve(templateDir, 'package.tw.json'), 'utf8'));
+        packageJSON = {
+            ...packageJSON,
+            dependencies: {
+                ...packageJSON.dependencies,
+                ...twPackageJSON.dependencies,
+            },
+        };
+    }
+    if (options.mode === FILE_ROUTER) {
+        const frPackageJSON = JSON.parse(await readFile(resolve(routerDir, 'package.fr.json'), 'utf8'));
+        packageJSON = {
+            ...packageJSON,
+            dependencies: {
+                ...packageJSON.dependencies,
+                ...frPackageJSON.dependencies,
+            },
+        };
+    }
+    for (const addOn of addOns) {
+        packageJSON = {
+            ...packageJSON,
+            dependencies: {
+                ...packageJSON.dependencies,
+                ...addOn.dependencies,
+            },
+            devDependencies: {
+                ...packageJSON.devDependencies,
+                ...addOn.devDependencies,
+            },
+            scripts: {
+                ...packageJSON.scripts,
+                ...addOn.scripts,
+            },
+        };
+    }
+    packageJSON.dependencies = sortObject(packageJSON.dependencies);
+    packageJSON.devDependencies = sortObject(packageJSON.devDependencies);
+    await writeFile(resolve(targetDir, 'package.json'), JSON.stringify(packageJSON, null, 2));
+}
+async function copyFilesRecursively(source, target, copyFile, templateFile) {
+    const sourceStat = statSync(source);
+    if (sourceStat.isDirectory()) {
+        const files = readdirSync(source);
+        for (const file of files) {
+            const sourceChild = resolve(source, file);
+            const targetChild = resolve(target, file);
+            await copyFilesRecursively(sourceChild, targetChild, copyFile, templateFile);
+        }
+    }
+    else {
+        let targetFile = basename(target).replace(/_dot_/, '.');
+        let isTemplate = false;
+        if (targetFile.endsWith('.ejs')) {
+            targetFile = targetFile.replace('.ejs', '');
+            isTemplate = true;
+        }
+        let isAppend = false;
+        if (targetFile.endsWith('.append')) {
+            targetFile = targetFile.replace('.append', '');
+            isAppend = true;
+        }
+        const targetPath = resolve(dirname(target), targetFile);
+        await mkdir(dirname(targetPath), {
+            recursive: true,
+        });
+        if (isTemplate) {
+            await templateFile(source, targetPath);
+        }
+        else {
+            if (isAppend) {
+                await appendFile(targetPath, (await readFile(source)).toString());
+            }
+            else {
+                await copyFile(source, targetPath);
+            }
+        }
+    }
+}
+export async function createApp(options, { silent = false, } = {}) {
+    const templateDirBase = fileURLToPath(new URL(`../templates/${options.framework}/base`, import.meta.url));
+    const templateDirRouter = fileURLToPath(new URL(`../templates/${options.framework}/${options.mode}`, import.meta.url));
+    const targetDir = resolve(process.cwd(), options.projectName);
+    if (existsSync(targetDir)) {
+        if (!silent) {
+            log.error(`Directory "${options.projectName}" already exists`);
+        }
+        return;
+    }
+    const copyFiles = createCopyFiles(targetDir);
+    const templateFile = createTemplateFile(options.projectName, options, targetDir);
+    const isAddOnEnabled = (id) => options.chosenAddOns.find((a) => a.id === id);
+    // Make the root directory
+    await mkdir(targetDir, { recursive: true });
+    // Setup the .vscode directory
+    await mkdir(resolve(targetDir, '.vscode'), { recursive: true });
+    await copyFile(resolve(templateDirBase, '_dot_vscode/settings.json'), resolve(targetDir, '.vscode/settings.json'));
+    // Fill the public directory
+    await mkdir(resolve(targetDir, 'public'), { recursive: true });
+    copyFiles(templateDirBase, [
+        './public/robots.txt',
+        './public/favicon.ico',
+        './public/manifest.json',
+        './public/logo192.png',
+        './public/logo512.png',
+    ]);
+    // Make the src directory
+    await mkdir(resolve(targetDir, 'src'), { recursive: true });
+    if (options.mode === FILE_ROUTER) {
+        await mkdir(resolve(targetDir, 'src/routes'), { recursive: true });
+        await mkdir(resolve(targetDir, 'src/components'), { recursive: true });
+    }
+    // Check for a .cursorrules file
+    if (existsSync(resolve(templateDirBase, '.cursorrules'))) {
+        await copyFile(resolve(templateDirBase, '.cursorrules'), resolve(targetDir, '.cursorrules'));
+    }
+    // Copy in Vite and Tailwind config and CSS
+    if (!options.tailwind) {
+        await copyFiles(templateDirBase, ['./src/App.css']);
+    }
+    await templateFile(templateDirBase, './vite.config.js.ejs');
+    await templateFile(templateDirBase, './src/styles.css.ejs');
+    copyFiles(templateDirBase, ['./src/logo.svg']);
+    // Setup the main, reportWebVitals and index.html files
+    if (!isAddOnEnabled('start') && options.framework === 'react') {
+        if (options.typescript) {
+            await templateFile(templateDirBase, './src/reportWebVitals.ts.ejs');
+        }
+        else {
+            await templateFile(templateDirBase, './src/reportWebVitals.ts.ejs', './src/reportWebVitals.js');
+        }
+    }
+    if (!isAddOnEnabled('start')) {
+        await templateFile(templateDirBase, './index.html.ejs');
+    }
+    // Setup tsconfig
+    if (options.typescript) {
+        await templateFile(templateDirBase, './tsconfig.json.ejs', './tsconfig.json');
+    }
+    // Setup the package.json file, optionally with typescript and tailwind
+    await createPackageJSON(options.projectName, options, templateDirBase, templateDirRouter, targetDir, options.chosenAddOns.map((addOn) => addOn.packageAdditions));
+    // Copy all the asset files from the addons
+    const s = silent ? null : spinner();
+    for (const phase of ['setup', 'add-on', 'example']) {
+        for (const addOn of options.chosenAddOns.filter((addOn) => addOn.phase === phase)) {
+            s?.start(`Setting up ${addOn.name}...`);
+            const addOnDir = resolve(addOn.directory, 'assets');
+            if (existsSync(addOnDir)) {
+                await copyFilesRecursively(addOnDir, targetDir, copyFile, async (file, targetFileName) => templateFile(addOnDir, file, targetFileName));
+            }
+            if (addOn.command) {
+                await execa(addOn.command.command, addOn.command.args || [], {
+                    cwd: targetDir,
+                });
+            }
+            s?.stop(`${addOn.name} setup complete`);
+        }
+    }
+    if (isAddOnEnabled('shadcn')) {
+        const shadcnComponents = new Set();
+        for (const addOn of options.chosenAddOns) {
+            if (addOn.shadcnComponents) {
+                for (const component of addOn.shadcnComponents) {
+                    shadcnComponents.add(component);
+                }
+            }
+        }
+        if (shadcnComponents.size > 0) {
+            s?.start(`Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`);
+            await execa('npx', ['shadcn@canary', 'add', ...shadcnComponents], {
+                cwd: targetDir,
+            });
+            s?.stop(`Installed shadcn components`);
+        }
+    }
+    const integrations = [];
+    if (existsSync(resolve(targetDir, 'src/integrations'))) {
+        for (const integration of readdirSync(resolve(targetDir, 'src/integrations'))) {
+            const integrationName = jsSafeName(integration);
+            if (existsSync(resolve(targetDir, 'src/integrations', integration, 'layout.tsx'))) {
+                integrations.push({
+                    type: 'layout',
+                    name: `${integrationName}Layout`,
+                    path: `integrations/${integration}/layout`,
+                });
+            }
+            if (existsSync(resolve(targetDir, 'src/integrations', integration, 'provider.tsx'))) {
+                integrations.push({
+                    type: 'provider',
+                    name: `${integrationName}Provider`,
+                    path: `integrations/${integration}/provider`,
+                });
+            }
+            if (existsSync(resolve(targetDir, 'src/integrations', integration, 'header-user.tsx'))) {
+                integrations.push({
+                    type: 'header-user',
+                    name: `${integrationName}Header`,
+                    path: `integrations/${integration}/header-user`,
+                });
+            }
+        }
+    }
+    const routes = [];
+    if (existsSync(resolve(targetDir, 'src/routes'))) {
+        for (const file of readdirSync(resolve(targetDir, 'src/routes'))) {
+            const name = file.replace(/\.tsx?|\.jsx?/, '');
+            const safeRouteName = jsSafeName(name);
+            routes.push({
+                path: `./routes/${name}`,
+                name: safeRouteName,
+            });
+        }
+    }
+    // Create the main entry point
+    if (!isAddOnEnabled('start')) {
+        if (options.typescript) {
+            await templateFile(templateDirRouter, './src/main.tsx.ejs', './src/main.tsx', {
+                routes,
+                integrations,
+            });
+        }
+        else {
+            await templateFile(templateDirRouter, './src/main.tsx.ejs', './src/main.jsx', {
+                routes,
+                integrations,
+            });
+        }
+    }
+    // Setup the app component. There are four variations, typescript/javascript and tailwind/non-tailwind.
+    if (options.mode === FILE_ROUTER) {
+        await templateFile(templateDirRouter, './src/routes/__root.tsx.ejs', './src/routes/__root.tsx', {
+            integrations,
+        });
+        await templateFile(templateDirBase, './src/App.tsx.ejs', './src/routes/index.tsx');
+    }
+    else {
+        await templateFile(templateDirBase, './src/App.tsx.ejs', options.typescript ? undefined : './src/App.jsx');
+        if (options.framework === 'react') {
+            await templateFile(templateDirBase, './src/App.test.tsx.ejs', options.typescript ? undefined : './src/App.test.jsx');
+        }
+    }
+    if (routes.length > 0) {
+        await templateFile(templateDirBase, './src/components/Header.tsx.ejs', './src/components/Header.tsx', {
+            integrations,
+        });
+    }
+    const warnings = [];
+    for (const addOn of options.chosenAddOns) {
+        if (addOn.warning) {
+            warnings.push(addOn.warning);
+        }
+    }
+    // Add .gitignore
+    await copyFile(resolve(templateDirBase, '_dot_gitignore'), resolve(targetDir, '.gitignore'));
+    // Create the README.md
+    await templateFile(templateDirBase, 'README.md.ejs');
+    // Install dependencies
+    s?.start(`Installing dependencies via ${options.packageManager}...`);
+    await execa(options.packageManager, ['install'], { cwd: targetDir });
+    s?.stop(`Installed dependencies`);
+    if (warnings.length > 0) {
+        if (!silent) {
+            log.warn(chalk.red(warnings.join('\n')));
+        }
+    }
+    if (options.git) {
+        s?.start(`Initializing git repository...`);
+        await execa('git', ['init'], { cwd: targetDir });
+        s?.stop(`Initialized git repository`);
+    }
+    if (!silent) {
+        outro(`Created your new TanStack app in '${basename(targetDir)}'.
+
+Use the following commands to start your app:
+% cd ${options.projectName}
+% ${options.packageManager === 'deno' ? 'deno start' : options.packageManager} ${isAddOnEnabled('start') ? 'dev' : 'start'}
+
+Please read README.md for more information on testing, styling, adding routes, react-query, etc.
+`);
+    }
+}