@tanstack/cta-engine 0.10.0-alpha.6 → 0.11.0

package/dist/add-ons.js

@@ -1,9 +1,10 @@
 import { readFile } from 'node:fs/promises';
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
 import chalk from 'chalk';
 import { getTemplatesRoot } from './templates.js';
 import { DEFAULT_FRAMEWORK } from './constants.js';
+import { readFileHelper } from './file-helper.js';
 function isDirectory(path) {
     return statSync(path).isDirectory();
 }
@@ -15,7 +16,7 @@ function findFilesRecursively(path, files) {
             findFilesRecursively(filePath, files);
         }
         else {
-            files[filePath] = readFileSync(filePath, 'utf-8').toString();
+            files[filePath] = readFileHelper(filePath);
         }
     }
 }
@@ -91,10 +92,9 @@ export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
     const finalAddOns = [...finalAddOnIDs].map((id) => addOns.find((a) => a.id === id));
     return finalAddOns;
 }
-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) {
+export async function listAddOns(options, { forcedMode, forcedAddOns = [], }) {
+    const addOns = await getAllAddOns(options.framework || DEFAULT_FRAMEWORK, forcedMode || options.template || 'typescript');
+    for (const addOn of addOns.filter((a) => !forcedAddOns.includes(a.id))) {
         console.log(`${chalk.bold(addOn.id)}: ${addOn.description}`);
     }
 }

package/dist/add.js

@@ -21,10 +21,7 @@ async function createOptions(json, addOns) {
     return {
         ...json,
         tailwind: true,
-        chosenAddOns: await finalizeAddOns(json.framework, json.mode, [
-            ...json.existingAddOns,
-            ...addOns,
-        ]),
+        chosenAddOns: await finalizeAddOns(json.framework, json.mode, [...json.existingAddOns, ...addOns]),
     };
 }
 async function runCreateApp(options) {
@@ -33,6 +30,7 @@ async function runCreateApp(options) {
         silent: true,
         environment,
         cwd: process.cwd(),
+        name: 'create-tsrouter-app',
     });
     return output;
 }

package/dist/cli.js

@@ -9,11 +9,9 @@ import { listAddOns } from './add-ons.js';
 import { DEFAULT_FRAMEWORK, SUPPORTED_FRAMEWORKS } from './constants.js';
 // import { initAddOn } from './custom-add-on.js'
 import { createDefaultEnvironment } from './environment.js';
-export function cli() {
+export function cli({ name, appName, forcedMode, forcedAddOns, }) {
     const program = new Command();
-    program
-        .name('create-tsrouter-app')
-        .description('CLI to create a new TanStack application');
+    program.name(name).description(`CLI to create a new ${appName} application`);
     // program
     //   .command('add')
     //   .argument('add-on', 'Name of the add-on (or add-ons separated by commas)')
@@ -32,24 +30,25 @@ export function cli() {
     //   .action(async () => {
     //     await initAddOn('overlay')
     //   })
-    program // 104 22
-        .argument('[project-name]', 'name of the project')
-        .option('--no-git', 'do not create a git repository')
-        .option('--target-dir <path>', 'the directory to create the project in')
+    program.argument('[project-name]', 'name of the project');
+    if (!forcedMode) {
+        program.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;
+        });
+    }
+    program
         .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('--overlay [url]', 'add an overlay from a URL', false)
         .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(', ')}`);
@@ -71,15 +70,23 @@ export function cli() {
         return addOns;
     })
         .option('--list-add-ons', 'list all available add-ons', false)
-        .option('--overlay [url]', 'add an overlay from a URL', false)
+        .option('--no-git', 'do not create a git repository')
+        .option('--target-dir <path>', 'the directory to create the project in')
         .option('--mcp', 'run the MCP server', false)
-        .option('--mcp-sse', 'run the MCP server in SSE mode', false)
-        .action(async (projectName, options) => {
+        .option('--mcp-sse', 'run the MCP server in SSE mode', false);
+    program.action(async (projectName, options) => {
         if (options.listAddOns) {
-            await listAddOns(options);
+            await listAddOns(options, {
+                forcedMode,
+                forcedAddOns,
+            });
         }
         else if (options.mcp || options.mcpSse) {
-            await runServer(!!options.mcpSse);
+            await runServer(!!options.mcpSse, {
+                forcedMode,
+                forcedAddOns,
+                appName,
+            });
         }
         else {
             try {
@@ -87,23 +94,29 @@ export function cli() {
                     projectName,
                     ...options,
                 };
-                let finalOptions = await normalizeOptions(cliOptions);
+                if (forcedMode) {
+                    cliOptions.template = forcedMode;
+                }
+                let finalOptions = await normalizeOptions(cliOptions, forcedAddOns);
                 if (finalOptions) {
-                    intro(`Creating a new TanStack app in ${projectName}...`);
+                    intro(`Creating a new ${appName} app in ${projectName}...`);
                 }
                 else {
-                    intro("Let's configure your TanStack application");
-                    finalOptions = await promptForOptions(cliOptions);
+                    intro(`Let's configure your ${appName} application`);
+                    finalOptions = await promptForOptions(cliOptions, {
+                        forcedMode,
+                        forcedAddOns,
+                    });
                 }
                 await createApp(finalOptions, {
                     environment: createDefaultEnvironment(),
                     cwd: options.targetDir || undefined,
+                    name,
+                    appName,
                 });
             }
             catch (error) {
-                log.error(error instanceof Error
-                    ? error.message
-                    : 'An unknown error occurred');
+                log.error(error instanceof Error ? error.message : 'An unknown error occurred');
                 process.exit(1);
             }
         }

package/dist/create-app.js

@@ -8,6 +8,7 @@ import { CODE_ROUTER, FILE_ROUTER } from './constants.js';
 import { sortObject } from './utils.js';
 import { writeConfigFile } from './config-file.js';
 import { packageManagerExecute } from './package-manager.js';
+import { getBinaryFile } from './file-helper.js';
 function createCopyFiles(environment, targetDir) {
     return async function copyFiles(templateDir, files, 
     // optionally copy files from a folder to the root
@@ -197,6 +198,11 @@ async function copyAddOnFile(environment, content, target, targetPath, templateF
         isAppend = true;
     }
     const finalTargetPath = resolve(dirname(targetPath), targetFile);
+    const binaryContent = getBinaryFile(content);
+    if (binaryContent) {
+        await environment.writeFile(finalTargetPath, binaryContent);
+        return;
+    }
     if (isTemplate) {
         await templateFile(content, finalTargetPath);
     }
@@ -209,7 +215,7 @@ async function copyAddOnFile(environment, content, target, targetPath, templateF
         }
     }
 }
-export async function createApp(options, { silent = false, environment, cwd, }) {
+export async function createApp(options, { silent = false, environment, cwd, appName = 'TanStack', }) {
     environment.startRun();
     const templateDirBase = resolve(getTemplatesRoot(), options.framework, 'base');
     const templateDirRouter = resolve(getTemplatesRoot(), options.framework, options.mode);
@@ -309,7 +315,7 @@ export async function createApp(options, { silent = false, environment, cwd, })
     // Copy all the asset files from the addons
     const s = silent ? null : spinner();
     for (const type of ['add-on', 'example']) {
-        for (const phase of ['setup', 'add-on']) {
+        for (const phase of ['setup', 'add-on', 'example']) {
             for (const addOn of options.chosenAddOns.filter((addOn) => addOn.phase === phase && addOn.type === type)) {
                 s?.start(`Setting up ${addOn.name}...`);
                 await runAddOn(addOn);
@@ -480,7 +486,7 @@ ${environment.getErrors().join('\n')}`;
         if (options.packageManager === 'deno') {
             startCommand = `deno ${isAddOnEnabled('start') ? 'task dev' : 'start'}`;
         }
-        outro(`Your TanStack app is ready in '${basename(targetDir)}'.
+        outro(`Your ${appName} app is ready in '${basename(targetDir)}'.
 
 Use the following commands to start your app:
 % cd ${options.projectName}

package/dist/custom-add-on.js

@@ -6,6 +6,7 @@ import { createMemoryEnvironment } from './environment.js';
 import { createApp } from './create-app.js';
 import { readConfigFile } from './config-file.js';
 import { finalizeAddOns } from './add-ons.js';
+import { readFileHelper } from './file-helper.js';
 const INFO_FILE = {
     'add-on': '.add-on/info.json',
     overlay: 'overlay-info.json',
@@ -78,9 +79,7 @@ export default (parentRoute: RootRoute) => createRoute({
 async function createOptions(json) {
     return {
         ...json,
-        chosenAddOns: await finalizeAddOns(json.framework, json.mode, [
-            ...json.existingAddOns,
-        ]),
+        chosenAddOns: await finalizeAddOns(json.framework, json.mode, [...json.existingAddOns]),
     };
 }
 async function runCreateApp(options) {
@@ -89,6 +88,7 @@ async function runCreateApp(options) {
         silent: true,
         environment,
         cwd: process.cwd(),
+        name: 'create-tsrouter-app',
     });
     return output;
 }
@@ -99,7 +99,7 @@ async function recursivelyGatherFiles(path, files) {
             await recursivelyGatherFiles(resolve(path, file.name), files);
         }
         else {
-            files[resolve(path, file.name)] = (await readFile(resolve(path, file.name))).toString();
+            files[resolve(path, file.name)] = readFileHelper(resolve(path, file.name));
         }
     }
 }

package/dist/file-helper.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { extname } from 'node:path';
+const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico'];
+export function readFileHelper(path) {
+    if (BINARY_EXTENSIONS.includes(extname(path))) {
+        return `base64::${readFileSync(path).toString('base64')}`;
+    }
+    else {
+        return readFileSync(path, 'utf-8').toString();
+    }
+}
+export function getBinaryFile(content) {
+    if (content.startsWith('base64::')) {
+        const binaryContent = Buffer.from(content.replace('base64::', ''), 'base64');
+        return binaryContent;
+    }
+    return null;
+}

package/dist/mcp.js

@@ -6,10 +6,6 @@ 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',
-});
 const tanStackReactAddOns = [
     {
         id: 'clerk',
@@ -52,62 +48,6 @@ const tanStackReactAddOns = [
         description: 'Add an AI chatbot example to the application',
     },
 ];
-server.tool('listTanStackReactAddOns', {}, () => {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(tanStackReactAddOns) }],
-    };
-});
-server.tool('createTanStackReactApplication', {
-    projectName: z
-        .string()
-        .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([
-        'clerk',
-        'convex',
-        'form',
-        'netlify',
-        'sentry',
-        'shadcn',
-        'start',
-        'store',
-        'tanstack-query',
-        'tanchat',
-    ]))
-        .describe('The IDs of the add-ons to install'),
-}, async ({ projectName, addOns, cwd }) => {
-    try {
-        process.chdir(cwd);
-        const chosenAddOns = await finalizeAddOns('react', 'file-router', addOns);
-        await createApp({
-            projectName: projectName.replace(/^\//, './'),
-            framework: 'react',
-            typescript: true,
-            tailwind: true,
-            packageManager: 'pnpm',
-            toolchain: 'none',
-            mode: 'file-router',
-            addOns: true,
-            chosenAddOns,
-            git: true,
-            variableValues: {},
-        }, {
-            silent: true,
-            environment: createDefaultEnvironment(),
-        });
-        return {
-            content: [{ type: 'text', text: 'Application created successfully' }],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                { type: 'text', text: `Error creating application: ${error}` },
-            ],
-        };
-    }
-});
 const tanStackSolidAddOns = [
     {
         id: 'solid-ui',
@@ -125,6 +65,10 @@ const tanStackSolidAddOns = [
         id: 'store',
         description: 'Enable the TanStack Store state management library',
     },
+    {
+        id: 'start',
+        description: 'Set this if you want a TanStack Start application that supports server functions or APIs',
+    },
     {
         id: 'tanstack-query',
         description: 'Enable TanStack Query for data fetching',
@@ -134,62 +78,136 @@ const tanStackSolidAddOns = [
         description: 'Add an AI chatbot example to the application',
     },
 ];
-server.tool('listTanStackSolidAddOns', {}, () => {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(tanStackSolidAddOns) }],
-    };
-});
-server.tool('createTanStackSolidApplication', {
-    projectName: z
-        .string()
-        .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',
-        'tanchat',
-    ]))
-        .describe('The IDs of the add-ons to install'),
-}, async ({ projectName, addOns, cwd }) => {
-    try {
-        process.chdir(cwd);
-        const chosenAddOns = await finalizeAddOns('solid', 'file-router', addOns);
-        await createApp({
-            projectName: projectName.replace(/^\//, './'),
-            framework: 'solid',
-            typescript: true,
-            tailwind: true,
-            packageManager: 'pnpm',
-            toolchain: 'none',
-            mode: 'file-router',
-            addOns: true,
-            chosenAddOns,
-            git: true,
-            variableValues: {},
-        }, {
-            silent: true,
-            environment: createDefaultEnvironment(),
-        });
+function createServer({ appName, forcedAddOns = [], name, }) {
+    const server = new McpServer({
+        name: `${appName} Application Builder`,
+        version: '1.0.0',
+    });
+    server.tool('listTanStackReactAddOns', {}, () => {
         return {
-            content: [{ type: 'text', text: 'Application created successfully' }],
+            content: [{ type: 'text', text: JSON.stringify(tanStackReactAddOns) }],
         };
-    }
-    catch (error) {
+    });
+    server.tool('createTanStackReactApplication', {
+        projectName: z
+            .string()
+            .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([
+            'clerk',
+            'convex',
+            'form',
+            'netlify',
+            'sentry',
+            'shadcn',
+            'start',
+            'store',
+            'tanstack-query',
+            'tanchat',
+        ]))
+            .describe('The IDs of the add-ons to install'),
+        targetDir: z
+            .string()
+            .describe('The directory to create the application in. Use the absolute path of the directory you want the application to be created in'),
+    }, async ({ projectName, addOns, cwd, targetDir }) => {
+        try {
+            process.chdir(cwd);
+            const chosenAddOns = await finalizeAddOns('react', 'file-router', Array.from(new Set([...addOns, ...forcedAddOns])));
+            await createApp({
+                projectName: projectName.replace(/^\//, './'),
+                framework: 'react',
+                typescript: true,
+                tailwind: true,
+                packageManager: 'pnpm',
+                toolchain: 'none',
+                mode: 'file-router',
+                addOns: true,
+                chosenAddOns,
+                git: true,
+                variableValues: {},
+            }, {
+                silent: true,
+                environment: createDefaultEnvironment(),
+                name,
+                cwd: targetDir,
+            });
+            return {
+                content: [{ type: 'text', text: 'Application created successfully' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: `Error creating application: ${error}` },
+                ],
+            };
+        }
+    });
+    server.tool('listTanStackSolidAddOns', {}, () => {
         return {
-            content: [
-                { type: 'text', text: `Error creating application: ${error}` },
-            ],
+            content: [{ type: 'text', text: JSON.stringify(tanStackSolidAddOns) }],
         };
-    }
-});
-export default async function runServer(sse) {
+    });
+    server.tool('createTanStackSolidApplication', {
+        projectName: z
+            .string()
+            .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',
+            'tanchat',
+        ]))
+            .describe('The IDs of the add-ons to install'),
+        targetDir: z
+            .string()
+            .describe('The directory to create the application in. Use the absolute path of the directory you want the application to be created in'),
+    }, async ({ projectName, addOns, cwd, targetDir }) => {
+        try {
+            process.chdir(cwd);
+            const chosenAddOns = await finalizeAddOns('solid', 'file-router', Array.from(new Set([...addOns, ...forcedAddOns])));
+            await createApp({
+                projectName: projectName.replace(/^\//, './'),
+                framework: 'solid',
+                typescript: true,
+                tailwind: true,
+                packageManager: 'pnpm',
+                toolchain: 'none',
+                mode: 'file-router',
+                addOns: true,
+                chosenAddOns,
+                git: true,
+                variableValues: {},
+            }, {
+                silent: true,
+                environment: createDefaultEnvironment(),
+                name,
+                cwd: targetDir,
+            });
+            return {
+                content: [{ type: 'text', text: 'Application created successfully' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: `Error creating application: ${error}` },
+                ],
+            };
+        }
+    });
+    return server;
+}
+export default async function runServer(sse, { forcedAddOns, appName, name, }) {
+    let transport = null;
+    const server = createServer({ appName, forcedAddOns, name });
     if (sse) {
         const app = express();
-        let transport = null;
         app.get('/sse', (req, res) => {
             transport = new SSEServerTransport('/messages', res);
             server.connect(transport);

package/dist/options.js

@@ -4,7 +4,7 @@ import { DEFAULT_TOOLCHAIN, SUPPORTED_TOOLCHAINS } from './toolchain.js';
 import { CODE_ROUTER, DEFAULT_FRAMEWORK, FILE_ROUTER } from './constants.js';
 import { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.js';
 // If all CLI options are provided, use them directly
-export async function normalizeOptions(cliOptions) {
+export async function normalizeOptions(cliOptions, forcedAddOns) {
     // in some cases, if you use windows/powershell, the argument for addons
     // if sepparated by comma is not really passed as an array, but as a string
     // with spaces, We need to normalize this edge case.
@@ -34,11 +34,17 @@ export async function normalizeOptions(cliOptions) {
         }
         let addOns = false;
         let chosenAddOns = [];
-        if (Array.isArray(cliOptions.addOns) || overlay?.dependsOn) {
+        if (Array.isArray(cliOptions.addOns) ||
+            overlay?.dependsOn ||
+            forcedAddOns) {
             addOns = true;
-            let finalAddOns = [...(overlay?.dependsOn || [])];
+            let finalAddOns = Array.from(new Set([...(overlay?.dependsOn || []), ...(forcedAddOns || [])]));
             if (cliOptions.addOns && Array.isArray(cliOptions.addOns)) {
-                finalAddOns = [...finalAddOns, ...cliOptions.addOns];
+                finalAddOns = Array.from(new Set([
+                    ...(forcedAddOns || []),
+                    ...finalAddOns,
+                    ...cliOptions.addOns,
+                ]));
             }
             chosenAddOns = await finalizeAddOns(cliOptions.framework || DEFAULT_FRAMEWORK, cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER, finalAddOns);
             tailwind = true;
@@ -101,7 +107,7 @@ async function collectVariables(variables) {
     }
     return responses;
 }
-export async function promptForOptions(cliOptions) {
+export async function promptForOptions(cliOptions, { forcedAddOns = [], forcedMode, }) {
     const options = {};
     options.framework = cliOptions.framework || DEFAULT_FRAMEWORK;
     if (options.framework === 'solid') {
@@ -128,7 +134,7 @@ export async function promptForOptions(cliOptions) {
         options.projectName = value;
     }
     // Router type selection
-    if (!cliOptions.template) {
+    if (!cliOptions.template && !forcedMode) {
         const routerType = await select({
             message: 'Select the router type:',
             options: [
@@ -149,6 +155,10 @@ export async function promptForOptions(cliOptions) {
         }
         options.mode = routerType;
     }
+    else if (forcedMode) {
+        options.mode = forcedMode === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
+        options.typescript = options.mode === FILE_ROUTER;
+    }
     else {
         options.mode =
             cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
@@ -234,7 +244,7 @@ export async function promptForOptions(cliOptions) {
     }
     options.chosenAddOns = [];
     if (Array.isArray(cliOptions.addOns)) {
-        options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, cliOptions.addOns);
+        options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, Array.from(new Set([...cliOptions.addOns, ...forcedAddOns])));
         options.tailwind = true;
     }
     else if (cliOptions.addOns) {
@@ -245,7 +255,9 @@ export async function promptForOptions(cliOptions) {
         if (options.typescript && addOns.length > 0) {
             const value = await multiselect({
                 message: 'What add-ons would you like for your project:',
-                options: addOns.map((addOn) => ({
+                options: addOns
+                    .filter((addOn) => !forcedAddOns.includes(addOn.id))
+                    .map((addOn) => ({
                     value: addOn.id,
                     label: addOn.name,
                     hint: addOn.description,
@@ -264,7 +276,9 @@ export async function promptForOptions(cliOptions) {
         if (options.typescript && examples.length > 0) {
             const value = await multiselect({
                 message: 'Would you like any examples?',
-                options: examples.map((addOn) => ({
+                options: examples
+                    .filter((addOn) => !forcedAddOns.includes(addOn.id))
+                    .map((addOn) => ({
                     value: addOn.id,
                     label: addOn.name,
                     hint: addOn.description,
@@ -277,11 +291,16 @@ export async function promptForOptions(cliOptions) {
             }
             selectedExamples = value;
         }
-        if (selectedAddOns.length > 0 || selectedExamples.length > 0) {
-            options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, [...selectedAddOns, ...selectedExamples]);
+        if (selectedAddOns.length > 0 ||
+            selectedExamples.length > 0 ||
+            forcedAddOns.length > 0) {
+            options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, Array.from(new Set([...selectedAddOns, ...selectedExamples, ...forcedAddOns])));
             options.tailwind = true;
         }
     }
+    else if (forcedAddOns.length > 0) {
+        options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, forcedAddOns);
+    }
     // Collect variables
     const variables = [];
     for (const addOn of options.chosenAddOns) {

package/dist/types/add-ons.d.ts

@@ -1,5 +1,8 @@
-import type { AddOn, CliOptions, Framework } from './types.js';
+import type { AddOn, CliOptions, Framework, TemplateOptions } from './types.js';
 export declare function getAllAddOns(framework: Framework, template: string): Promise<Array<AddOn>>;
 export declare function finalizeAddOns(framework: Framework, template: string, chosenAddOnIDs: Array<string>): Promise<Array<AddOn>>;
-export declare function listAddOns(options: CliOptions): Promise<void>;
+export declare function listAddOns(options: CliOptions, { forcedMode, forcedAddOns, }: {
+    forcedMode?: TemplateOptions;
+    forcedAddOns?: Array<string>;
+}): Promise<void>;
 export declare function loadRemoteAddOn(url: string): Promise<AddOn>;

package/dist/types/cli.d.ts

@@ -1 +1,6 @@
-export declare function cli(): void;
+export declare function cli({ name, appName, forcedMode, forcedAddOns, }: {
+    name: string;
+    appName: string;
+    forcedMode?: 'typescript' | 'javascript' | 'file-router';
+    forcedAddOns?: Array<string>;
+}): void;