create-start-app 0.6.1 → 0.6.3

package/dist/cli.js

@@ -7,6 +7,7 @@ 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
@@ -72,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,7 +13,7 @@ function sortObject(obj) {
         return acc;
     }, {});
 }
-function createCopyFiles(targetDir) {
+function createCopyFiles(environment, targetDir) {
     return async function copyFiles(templateDir, files, 
     // optionally copy files from a folder to the root
     toRoot) {
@@ -27,7 +23,7 @@ function createCopyFiles(targetDir) {
                 const fileNoPath = targetFileName.split('/').pop();
                 targetFileName = fileNoPath ? `./${fileNoPath}` : targetFileName;
             }
-            await copyFile(resolve(templateDir, file), resolve(targetDir, targetFileName));
+            await environment.copyFile(resolve(templateDir, file), resolve(targetDir, targetFileName));
         }
     };
 }
@@ -37,7 +33,7 @@ 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,
@@ -56,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);
@@ -75,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: {
@@ -95,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: {
@@ -105,7 +98,7 @@ async function createPackageJSON(projectName, options, templateDir, routerDir, t
         };
     }
     if (options.toolchain === 'biome') {
-        const biomePackageJSON = JSON.parse(await readFile(resolve(templateDir, 'package.biome.json'), 'utf8'));
+        const biomePackageJSON = JSON.parse(await environment.readFile(resolve(templateDir, 'package.biome.json'), 'utf8'));
         packageJSON = {
             ...packageJSON,
             scripts: {
@@ -119,7 +112,7 @@ async function createPackageJSON(projectName, options, templateDir, routerDir, t
         };
     }
     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: {
@@ -147,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 {
@@ -172,49 +164,43 @@ 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, }) {
+    environment.startRun();
     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 });
     switch (options.toolchain) {
         case 'biome':
-            await copyFile(resolve(templateDirBase, '_dot_vscode/settings.biome.json'), resolve(targetDir, '.vscode/settings.json'));
+            await environment.copyFile(resolve(templateDirBase, '_dot_vscode/settings.biome.json'), resolve(targetDir, '.vscode/settings.json'));
             break;
         case 'none':
         default:
-            await copyFile(resolve(templateDirBase, '_dot_vscode/settings.json'), resolve(targetDir, '.vscode/settings.json'));
+            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',
@@ -222,15 +208,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) {
@@ -259,20 +239,18 @@ export async function createApp(options, { silent = false, } = {}) {
         await templateFile(templateDirBase, './tsconfig.json.ejs', './tsconfig.json');
     }
     // Setup the package.json file, optionally with typescript, tailwind and biome
-    await createPackageJSON(options.projectName, options, templateDirBase, templateDirRouter, targetDir, options.chosenAddOns.map((addOn) => addOn.packageAdditions));
+    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`);
         }
@@ -288,31 +266,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`,
@@ -322,8 +298,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({
@@ -374,12 +350,12 @@ 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) {
@@ -391,23 +367,28 @@ export async function createApp(options, { silent = false, } = {}) {
         switch (options.packageManager) {
             case 'pnpm':
                 // pnpm automatically forwards extra arguments
-                await execa(options.packageManager, ['run', 'check', '--fix'], {
-                    cwd: targetDir,
-                });
+                await environment.execute(options.packageManager, ['run', 'check', '--fix'], targetDir);
                 break;
             default:
-                await execa(options.packageManager, ['run', 'check', '--', '--fix'], {
-                    cwd: targetDir,
-                });
+                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`);
     }
+    environment.finishRun();
+    let errorStatement = '';
+    if (environment.getErrors().length) {
+        errorStatement = `
+
+${chalk.red('There were errors encountered during this process:')}
+
+${environment.getErrors().join('\n')}`;
+    }
     if (!silent) {
         outro(`Created your new TanStack app in '${basename(targetDir)}'.
 
@@ -415,7 +396,6 @@ 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.
-`);
+Please read README.md for more information on testing, styling, adding routes, react-query, etc.${errorStatement}`);
     }
 }

package/dist/environment.js

@@ -0,0 +1,43 @@
+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() {
+    let errors = [];
+    return {
+        startRun: () => {
+            errors = [];
+        },
+        finishRun: () => { },
+        getErrors: () => errors,
+        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) => {
+            try {
+                await execa(command, args, {
+                    cwd,
+                });
+            }
+            catch {
+                errors.push(`Command "${command} ${args.join(' ')}" did not run successfully. Please run this manually in your project.`);
+            }
+        },
+        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',
@@ -93,6 +94,7 @@ server.tool('createTanStackReactApplication', {
             variableValues: {},
         }, {
             silent: true,
+            environment: createDefaultEnvironment(),
         });
         return {
             content: [{ type: 'text', text: 'Application created successfully' }],
@@ -170,6 +172,7 @@ server.tool('createTanStackSolidApplication', {
             variableValues: {},
         }, {
             silent: true,
+            environment: createDefaultEnvironment(),
         });
         return {
             content: [{ type: 'text', text: 'Application created successfully' }],

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "create-start-app",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "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

@@ -10,6 +10,8 @@ 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'
@@ -115,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