create-start-app 0.5.0 → 0.6.2

package/README.md

@@ -30,6 +30,7 @@ This will start an interactive CLI that guides you through the setup process, al
 - TypeScript support
 - Tailwind CSS integration
 - Package manager
+- Toolchain
 - Git initialization
 
 ## Command Line Options
@@ -45,6 +46,7 @@ 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`, `bun`, or `deno`)
+- `--toolchain`: Specify your toolchain solution for formatting/linting (`biome`)
 - `--no-git`: Do not initialize a git repository
 - `--add-ons`: Enable add-on selection or specify add-ons to install
 
@@ -94,6 +96,12 @@ Choose your preferred package manager (`npm`, `bun`, `yarn`, `pnpm`, or `deno`)
 
 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.
 
+### Toolchain
+
+Choose your preferred solution for formatting and linting either through the interactive CLI or using the `--toolchain` flag.
+
+Setting this flag to `biome` will configure it as your toolchain of choice, adding a `biome.json` to the root of the project. Consult the [biome documentation](https://biomejs.dev/guides/getting-started/) for further customization.
+
 ## Add-ons (experimental)
 
 You can enable add-on selection:

package/dist/cli.js

@@ -3,9 +3,11 @@ 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 { SUPPORTED_TOOLCHAINS } from './toolchain.js';
 import runServer from './mcp.js';
 import { listAddOns } from './add-ons.js';
 import { DEFAULT_FRAMEWORK, SUPPORTED_FRAMEWORKS } from './constants.js';
+import { createDefaultEnvironment } from './environment.js';
 export function cli() {
     const program = new Command();
     program
@@ -32,6 +34,12 @@ export function cli() {
             throw new InvalidArgumentError(`Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
         }
         return value;
+    })
+        .option(`--toolchain <${SUPPORTED_TOOLCHAINS.join('|')}>`, `Explicitly tell the CLI to use this toolchain`, (value) => {
+        if (!SUPPORTED_TOOLCHAINS.includes(value)) {
+            throw new InvalidArgumentError(`Invalid toolchain: ${value}. The following are allowed: ${SUPPORTED_TOOLCHAINS.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) => {
@@ -65,7 +73,9 @@ export function cli() {
                     intro("Let's configure your TanStack application");
                     finalOptions = await promptForOptions(cliOptions);
                 }
-                await createApp(finalOptions);
+                await createApp(finalOptions, {
+                    environment: createDefaultEnvironment(),
+                });
             }
             catch (error) {
                 log.error(error instanceof Error

package/dist/create-app.js

@@ -1,10 +1,6 @@
-#!/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';
@@ -17,11 +13,17 @@ function sortObject(obj) {
         return acc;
     }, {});
 }
-function createCopyFiles(targetDir) {
-    return async function copyFiles(templateDir, files) {
+function createCopyFiles(environment, targetDir) {
+    return async function copyFiles(templateDir, files, 
+    // optionally copy files from a folder to the root
+    toRoot) {
         for (const file of files) {
-            const targetFileName = file.replace('.tw', '');
-            await copyFile(resolve(templateDir, file), resolve(targetDir, targetFileName));
+            let targetFileName = file.replace('.tw', '');
+            if (toRoot) {
+                const fileNoPath = targetFileName.split('/').pop();
+                targetFileName = fileNoPath ? `./${fileNoPath}` : targetFileName;
+            }
+            await environment.copyFile(resolve(templateDir, file), resolve(targetDir, targetFileName));
         }
     };
 }
@@ -31,13 +33,14 @@ function jsSafeName(name) {
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
         .join('');
 }
-function createTemplateFile(projectName, options, targetDir) {
+function createTemplateFile(environment, projectName, options, targetDir) {
     return async function templateFile(templateDir, file, targetFileName, extraTemplateValues) {
         const templateValues = {
             packageManager: options.packageManager,
             projectName: projectName,
             typescript: options.typescript,
             tailwind: options.tailwind,
+            toolchain: options.toolchain,
             js: options.typescript ? 'ts' : 'js',
             jsx: options.typescript ? 'tsx' : 'jsx',
             fileRouter: options.mode === FILE_ROUTER,
@@ -49,7 +52,7 @@ function createTemplateFile(projectName, options, targetDir) {
             addOns: options.chosenAddOns,
             ...extraTemplateValues,
         };
-        const template = await readFile(resolve(templateDir, file), 'utf-8');
+        const template = await environment.readFile(resolve(templateDir, file), 'utf-8');
         let content = '';
         try {
             content = render(template, templateValues);
@@ -68,17 +71,14 @@ function createTemplateFile(projectName, options, targetDir) {
                 parser: 'typescript',
             });
         }
-        await mkdir(dirname(resolve(targetDir, target)), {
-            recursive: true,
-        });
-        await writeFile(resolve(targetDir, target), content);
+        await environment.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'));
+async function createPackageJSON(environment, projectName, options, templateDir, routerDir, targetDir, addOns) {
+    let packageJSON = JSON.parse(await environment.readFile(resolve(templateDir, 'package.json'), 'utf8'));
     packageJSON.name = projectName;
     if (options.typescript) {
-        const tsPackageJSON = JSON.parse(await readFile(resolve(templateDir, 'package.ts.json'), 'utf8'));
+        const tsPackageJSON = JSON.parse(await environment.readFile(resolve(templateDir, 'package.ts.json'), 'utf8'));
         packageJSON = {
             ...packageJSON,
             devDependencies: {
@@ -88,7 +88,7 @@ async function createPackageJSON(projectName, options, templateDir, routerDir, t
         };
     }
     if (options.tailwind) {
-        const twPackageJSON = JSON.parse(await readFile(resolve(templateDir, 'package.tw.json'), 'utf8'));
+        const twPackageJSON = JSON.parse(await environment.readFile(resolve(templateDir, 'package.tw.json'), 'utf8'));
         packageJSON = {
             ...packageJSON,
             dependencies: {
@@ -97,8 +97,22 @@ async function createPackageJSON(projectName, options, templateDir, routerDir, t
             },
         };
     }
+    if (options.toolchain === 'biome') {
+        const biomePackageJSON = JSON.parse(await environment.readFile(resolve(templateDir, 'package.biome.json'), 'utf8'));
+        packageJSON = {
+            ...packageJSON,
+            scripts: {
+                ...packageJSON.scripts,
+                ...biomePackageJSON.scripts,
+            },
+            devDependencies: {
+                ...packageJSON.devDependencies,
+                ...biomePackageJSON.devDependencies,
+            },
+        };
+    }
     if (options.mode === FILE_ROUTER) {
-        const frPackageJSON = JSON.parse(await readFile(resolve(routerDir, 'package.fr.json'), 'utf8'));
+        const frPackageJSON = JSON.parse(await environment.readFile(resolve(routerDir, 'package.fr.json'), 'utf8'));
         packageJSON = {
             ...packageJSON,
             dependencies: {
@@ -126,16 +140,15 @@ async function createPackageJSON(projectName, options, templateDir, routerDir, t
     }
     packageJSON.dependencies = sortObject(packageJSON.dependencies);
     packageJSON.devDependencies = sortObject(packageJSON.devDependencies);
-    await writeFile(resolve(targetDir, 'package.json'), JSON.stringify(packageJSON, null, 2));
+    await environment.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);
+async function copyFilesRecursively(environment, source, target, templateFile) {
+    if (environment.isDirectory(source)) {
+        const files = environment.readdir(source);
         for (const file of files) {
             const sourceChild = resolve(source, file);
             const targetChild = resolve(target, file);
-            await copyFilesRecursively(sourceChild, targetChild, copyFile, templateFile);
+            await copyFilesRecursively(environment, sourceChild, targetChild, templateFile);
         }
     }
     else {
@@ -151,42 +164,42 @@ async function copyFilesRecursively(source, target, copyFile, templateFile) {
             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());
+                await environment.appendFile(targetPath, (await environment.readFile(source)).toString());
             }
             else {
-                await copyFile(source, targetPath);
+                await environment.copyFile(source, targetPath);
             }
         }
     }
 }
-export async function createApp(options, { silent = false, } = {}) {
+export async function createApp(options, { silent = false, environment, }) {
     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 (environment.exists(targetDir)) {
         if (!silent) {
             log.error(`Directory "${options.projectName}" already exists`);
         }
         return;
     }
-    const copyFiles = createCopyFiles(targetDir);
-    const templateFile = createTemplateFile(options.projectName, options, targetDir);
+    const copyFiles = createCopyFiles(environment, targetDir);
+    const templateFile = createTemplateFile(environment, 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'));
+    switch (options.toolchain) {
+        case 'biome':
+            await environment.copyFile(resolve(templateDirBase, '_dot_vscode/settings.biome.json'), resolve(targetDir, '.vscode/settings.json'));
+            break;
+        case 'none':
+        default:
+            await environment.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',
@@ -194,15 +207,9 @@ export async function createApp(options, { silent = false, } = {}) {
         './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'));
+    if (environment.exists(resolve(templateDirBase, '.cursorrules'))) {
+        await environment.copyFile(resolve(templateDirBase, '.cursorrules'), resolve(targetDir, '.cursorrules'));
     }
     // Copy in Vite and Tailwind config and CSS
     if (!options.tailwind) {
@@ -211,6 +218,9 @@ export async function createApp(options, { silent = false, } = {}) {
     await templateFile(templateDirBase, './vite.config.js.ejs');
     await templateFile(templateDirBase, './src/styles.css.ejs');
     copyFiles(templateDirBase, ['./src/logo.svg']);
+    if (options.toolchain === 'biome') {
+        copyFiles(templateDirBase, ['./toolchain/biome.json'], true);
+    }
     // Setup the main, reportWebVitals and index.html files
     if (!isAddOnEnabled('start') && options.framework === 'react') {
         if (options.typescript) {
@@ -227,21 +237,19 @@ export async function createApp(options, { silent = false, } = {}) {
     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));
+    // Setup the package.json file, optionally with typescript, tailwind and biome
+    await createPackageJSON(environment, 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 (environment.exists(addOnDir)) {
+                await copyFilesRecursively(environment, addOnDir, targetDir, async (file, targetFileName) => templateFile(addOnDir, file, targetFileName));
             }
             if (addOn.command) {
-                await execa(addOn.command.command, addOn.command.args || [], {
-                    cwd: targetDir,
-                });
+                await environment.execute(addOn.command.command, addOn.command.args || [], targetDir);
             }
             s?.stop(`${addOn.name} setup complete`);
         }
@@ -257,31 +265,29 @@ export async function createApp(options, { silent = false, } = {}) {
         }
         if (shadcnComponents.size > 0) {
             s?.start(`Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`);
-            await execa('npx', ['shadcn@canary', 'add', ...shadcnComponents], {
-                cwd: targetDir,
-            });
+            await environment.execute('npx', ['shadcn@canary', 'add', ...shadcnComponents], targetDir);
             s?.stop(`Installed shadcn components`);
         }
     }
     const integrations = [];
-    if (existsSync(resolve(targetDir, 'src/integrations'))) {
-        for (const integration of readdirSync(resolve(targetDir, 'src/integrations'))) {
+    if (environment.exists(resolve(targetDir, 'src/integrations'))) {
+        for (const integration of environment.readdir(resolve(targetDir, 'src/integrations'))) {
             const integrationName = jsSafeName(integration);
-            if (existsSync(resolve(targetDir, 'src/integrations', integration, 'layout.tsx'))) {
+            if (environment.exists(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'))) {
+            if (environment.exists(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'))) {
+            if (environment.exists(resolve(targetDir, 'src/integrations', integration, 'header-user.tsx'))) {
                 integrations.push({
                     type: 'header-user',
                     name: `${integrationName}Header`,
@@ -291,8 +297,8 @@ export async function createApp(options, { silent = false, } = {}) {
         }
     }
     const routes = [];
-    if (existsSync(resolve(targetDir, 'src/routes'))) {
-        for (const file of readdirSync(resolve(targetDir, 'src/routes'))) {
+    if (environment.exists(resolve(targetDir, 'src/routes'))) {
+        for (const file of environment.readdir(resolve(targetDir, 'src/routes'))) {
             const name = file.replace(/\.tsx?|\.jsx?/, '');
             const safeRouteName = jsSafeName(name);
             routes.push({
@@ -343,21 +349,34 @@ export async function createApp(options, { silent = false, } = {}) {
         }
     }
     // Add .gitignore
-    await copyFile(resolve(templateDirBase, '_dot_gitignore'), resolve(targetDir, '.gitignore'));
+    await environment.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 });
+    await environment.execute(options.packageManager, ['install'], targetDir);
     s?.stop(`Installed dependencies`);
     if (warnings.length > 0) {
         if (!silent) {
             log.warn(chalk.red(warnings.join('\n')));
         }
     }
+    if (options.toolchain === 'biome') {
+        s?.start(`Applying toolchain ${options.toolchain}...`);
+        switch (options.packageManager) {
+            case 'pnpm':
+                // pnpm automatically forwards extra arguments
+                await environment.execute(options.packageManager, ['run', 'check', '--fix'], targetDir);
+                break;
+            default:
+                await environment.execute(options.packageManager, ['run', 'check', '--', '--fix'], targetDir);
+                break;
+        }
+        s?.stop(`Applied toolchain ${options.toolchain}...`);
+    }
     if (options.git) {
         s?.start(`Initializing git repository...`);
-        await execa('git', ['init'], { cwd: targetDir });
+        await environment.execute('git', ['init'], targetDir);
         s?.stop(`Initialized git repository`);
     }
     if (!silent) {

package/dist/environment.js

@@ -0,0 +1,32 @@
+import { appendFile, copyFile, mkdir, readFile, writeFile, } from 'node:fs/promises';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { execa } from 'execa';
+export function createDefaultEnvironment() {
+    return {
+        appendFile: async (path, contents) => {
+            await mkdir(dirname(path), { recursive: true });
+            return appendFile(path, contents);
+        },
+        copyFile: async (from, to) => {
+            await mkdir(dirname(to), { recursive: true });
+            return copyFile(from, to);
+        },
+        writeFile: async (path, contents) => {
+            await mkdir(dirname(path), { recursive: true });
+            return writeFile(path, contents);
+        },
+        execute: async (command, args, cwd) => {
+            await execa(command, args, {
+                cwd,
+            });
+        },
+        readFile: (path, encoding) => readFile(path, { encoding: encoding || 'utf8' }),
+        exists: (path) => existsSync(path),
+        readdir: (path) => readdirSync(path),
+        isDirectory: (path) => {
+            const stat = statSync(path);
+            return stat.isDirectory();
+        },
+    };
+}

package/dist/mcp.js

@@ -5,6 +5,7 @@ import express from 'express';
 import { z } from 'zod';
 import { createApp } from './create-app.js';
 import { finalizeAddOns } from './add-ons.js';
+import { createDefaultEnvironment } from './environment.js';
 const server = new McpServer({
     name: 'Demo',
     version: '1.0.0',
@@ -46,6 +47,10 @@ const tanStackReactAddOns = [
         id: 'store',
         description: 'Enable the TanStack Store state management library',
     },
+    {
+        id: 'tanchat',
+        description: 'Add an AI chatbot example to the application',
+    },
 ];
 server.tool('listTanStackReactAddOns', {}, () => {
     return {
@@ -68,6 +73,7 @@ server.tool('createTanStackReactApplication', {
         'start',
         'store',
         'tanstack-query',
+        'tanchat',
     ]))
         .describe('The IDs of the add-ons to install'),
 }, async ({ projectName, addOns, cwd }) => {
@@ -80,6 +86,7 @@ server.tool('createTanStackReactApplication', {
             typescript: true,
             tailwind: true,
             packageManager: 'pnpm',
+            toolchain: 'none',
             mode: 'file-router',
             addOns: true,
             chosenAddOns,
@@ -87,6 +94,7 @@ server.tool('createTanStackReactApplication', {
             variableValues: {},
         }, {
             silent: true,
+            environment: createDefaultEnvironment(),
         });
         return {
             content: [{ type: 'text', text: 'Application created successfully' }],
@@ -121,6 +129,10 @@ const tanStackSolidAddOns = [
         id: 'tanstack-query',
         description: 'Enable TanStack Query for data fetching',
     },
+    {
+        id: 'tanchat',
+        description: 'Add an AI chatbot example to the application',
+    },
 ];
 server.tool('listTanStackSolidAddOns', {}, () => {
     return {
@@ -133,7 +145,14 @@ server.tool('createTanStackSolidApplication', {
         .describe('The package.json module name of the application (will also be the directory name)'),
     cwd: z.string().describe('The directory to create the application in'),
     addOns: z
-        .array(z.enum(['solid-ui', 'form', 'sentry', 'store', 'tanstack-query']))
+        .array(z.enum([
+        'solid-ui',
+        'form',
+        'sentry',
+        'store',
+        'tanstack-query',
+        'tanchat',
+    ]))
         .describe('The IDs of the add-ons to install'),
 }, async ({ projectName, addOns, cwd }) => {
     try {
@@ -145,6 +164,7 @@ server.tool('createTanStackSolidApplication', {
             typescript: true,
             tailwind: true,
             packageManager: 'pnpm',
+            toolchain: 'none',
             mode: 'file-router',
             addOns: true,
             chosenAddOns,
@@ -152,6 +172,7 @@ server.tool('createTanStackSolidApplication', {
             variableValues: {},
         }, {
             silent: true,
+            environment: createDefaultEnvironment(),
         });
         return {
             content: [{ type: 'text', text: 'Application created successfully' }],

package/dist/options.js

@@ -1,5 +1,6 @@
 import { cancel, confirm, isCancel, multiselect, select, text, } from '@clack/prompts';
 import { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
+import { DEFAULT_TOOLCHAIN, SUPPORTED_TOOLCHAINS } from './toolchain.js';
 import { CODE_ROUTER, DEFAULT_FRAMEWORK, FILE_ROUTER } from './constants.js';
 import { finalizeAddOns, getAllAddOns } from './add-ons.js';
 // If all CLI options are provided, use them directly
@@ -26,6 +27,7 @@ export async function normalizeOptions(cliOptions) {
             typescript,
             tailwind,
             packageManager: cliOptions.packageManager || DEFAULT_PACKAGE_MANAGER,
+            toolchain: cliOptions.toolchain || DEFAULT_TOOLCHAIN,
             mode: cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER,
             git: !!cliOptions.git,
             addOns,
@@ -145,7 +147,7 @@ export async function promptForOptions(cliOptions) {
         }
     }
     // Tailwind selection
-    if (cliOptions.tailwind === undefined && options.framework === 'react') {
+    if (!cliOptions.tailwind && options.framework === 'react') {
         const tailwind = await confirm({
             message: 'Would you like to use Tailwind CSS?',
             initialValue: true,
@@ -184,6 +186,25 @@ export async function promptForOptions(cliOptions) {
     else {
         options.packageManager = cliOptions.packageManager;
     }
+    // Toolchain selection
+    if (cliOptions.toolchain === undefined) {
+        const tc = await select({
+            message: 'Select toolchain',
+            options: SUPPORTED_TOOLCHAINS.map((tc) => ({
+                value: tc,
+                label: tc,
+            })),
+            initialValue: DEFAULT_TOOLCHAIN,
+        });
+        if (isCancel(tc)) {
+            cancel('Operation cancelled.');
+            process.exit(0);
+        }
+        options.toolchain = tc;
+    }
+    else {
+        options.toolchain = cliOptions.toolchain;
+    }
     options.chosenAddOns = [];
     if (Array.isArray(cliOptions.addOns)) {
         options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, cliOptions.addOns);

package/dist/toolchain.js

@@ -0,0 +1,2 @@
+export const SUPPORTED_TOOLCHAINS = ['none', 'biome'];
+export const DEFAULT_TOOLCHAIN = 'none';

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "create-start-app",
-  "version": "0.5.0",
+  "version": "0.6.2",
   "description": "Tanstack Application Builder",
   "bin": "./dist/index.js",
   "type": "module",
   "scripts": {
     "build": "tsc",
     "start": "tsc && node dist/index.js",
-    "test": "npm run test:lint",
+    "test": "npm run test:lint && vitest --run",
+    "test:watch": "vitest",
     "cipublish": "node scripts/publish.js",
     "test:lint": "eslint ./src",
     "mcp": "tsc && npx @modelcontextprotocol/inspector dist/index.js --mcp"
@@ -39,6 +40,7 @@
     "execa": "^9.5.2",
     "express": "^4.21.2",
     "prettier": "^3.5.0",
+    "vitest": "^3.0.8",
     "zod": "^3.24.2"
   },
   "devDependencies": {

package/src/cli.ts

@@ -4,12 +4,16 @@ 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 { SUPPORTED_TOOLCHAINS } from './toolchain.js'
 
 import runServer from './mcp.js'
 import { listAddOns } from './add-ons.js'
 import { DEFAULT_FRAMEWORK, SUPPORTED_FRAMEWORKS } from './constants.js'
 
+import { createDefaultEnvironment } from './environment.js'
+
 import type { PackageManager } from './package-manager.js'
+import type { ToolChain } from './toolchain.js'
 import type { CliOptions, Framework } from './types.js'
 
 export function cli() {
@@ -65,6 +69,20 @@ export function cli() {
         return value as PackageManager
       },
     )
+    .option<ToolChain>(
+      `--toolchain <${SUPPORTED_TOOLCHAINS.join('|')}>`,
+      `Explicitly tell the CLI to use this toolchain`,
+      (value) => {
+        if (!SUPPORTED_TOOLCHAINS.includes(value as ToolChain)) {
+          throw new InvalidArgumentError(
+            `Invalid toolchain: ${value}. The following are allowed: ${SUPPORTED_TOOLCHAINS.join(
+              ', ',
+            )}`,
+          )
+        }
+        return value as ToolChain
+      },
+    )
     .option('--tailwind', 'add Tailwind CSS', false)
     .option<Array<string> | boolean>(
       '--add-ons [...add-ons]',
@@ -99,7 +117,9 @@ export function cli() {
             intro("Let's configure your TanStack application")
             finalOptions = await promptForOptions(cliOptions)
           }
-          await createApp(finalOptions)
+          await createApp(finalOptions, {
+            environment: createDefaultEnvironment(),
+          })
         } catch (error) {
           log.error(
             error instanceof Error