@tanstack/cta-cli 0.10.0-alpha.19 → 0.10.0-alpha.21

package/dist/options.js

@@ -1,361 +1,70 @@
-import { cancel, confirm, isCancel, multiselect, select, text, } from '@clack/prompts';
-import { CODE_ROUTER, DEFAULT_PACKAGE_MANAGER, FILE_ROUTER, SUPPORTED_PACKAGE_MANAGERS, finalizeAddOns, getAllAddOns, getFrameworkById, getPackageManager, loadRemoteAddOn, } from '@tanstack/cta-engine';
-// If all CLI options are provided, use them directly
-export async function normalizeOptions(cliOptions, forcedMode, 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.
-    if (Array.isArray(cliOptions.addOns) && cliOptions.addOns.length === 1) {
-        const parseSeparatedArgs = cliOptions.addOns[0].split(' ');
-        if (parseSeparatedArgs.length > 1) {
-            cliOptions.addOns = parseSeparatedArgs;
-        }
-    }
-    if (cliOptions.projectName) {
-        let typescript = cliOptions.template === 'typescript' ||
-            cliOptions.template === 'file-router' ||
-            cliOptions.framework === 'solid';
-        let tailwind = !!cliOptions.tailwind;
-        if (cliOptions.framework === 'solid') {
-            tailwind = true;
-        }
-        let mode = cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
-        const starter = cliOptions.starter
-            ? (await loadRemoteAddOn(cliOptions.starter))
-            : undefined;
-        if (starter) {
-            tailwind = starter.tailwind;
-            typescript = starter.typescript;
-            cliOptions.framework = starter.framework;
-            mode = starter.mode;
-        }
-        let addOns = false;
-        let chosenAddOns = [];
-        if (Array.isArray(cliOptions.addOns) ||
-            starter?.dependsOn ||
-            forcedAddOns ||
-            cliOptions.toolchain) {
-            addOns = true;
-            let finalAddOns = Array.from(new Set([...(starter?.dependsOn || []), ...(forcedAddOns || [])]));
-            if (cliOptions.addOns && Array.isArray(cliOptions.addOns)) {
-                finalAddOns = Array.from(new Set([
-                    ...(forcedAddOns || []),
-                    ...finalAddOns,
-                    ...cliOptions.addOns,
-                ]));
-            }
-            const framework = getFrameworkById(cliOptions.framework || 'react-cra');
-            if (cliOptions.toolchain) {
-                finalAddOns.push(cliOptions.toolchain);
-            }
-            chosenAddOns = await finalizeAddOns(framework, forcedMode || cliOptions.template === 'file-router'
-                ? FILE_ROUTER
-                : CODE_ROUTER, finalAddOns);
-            tailwind = true;
-            typescript = true;
-        }
-        return {
-            // TODO: This is a bit to fix the default framework
-            framework: getFrameworkById(cliOptions.framework || 'react-cra'),
-            projectName: cliOptions.projectName,
-            typescript,
-            tailwind,
-            packageManager: cliOptions.packageManager ||
-                getPackageManager() ||
-                DEFAULT_PACKAGE_MANAGER,
-            mode,
-            git: !!cliOptions.git,
-            addOns,
-            chosenAddOns,
-            variableValues: {},
-            starter,
-        };
-    }
-}
-async function collectVariables(variables) {
-    const responses = {};
-    for (const variable of variables) {
-        if (variable.type === 'string') {
-            const response = await text({
-                message: variable.description,
-                initialValue: variable.default,
-            });
-            if (isCancel(response)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            responses[variable.name] = response;
-        }
-        else if (variable.type === 'number') {
-            const response = await text({
-                message: variable.description,
-                initialValue: variable.default.toString(),
-            });
-            if (isCancel(response)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            responses[variable.name] = Number(response);
-        }
-        else {
-            const response = await confirm({
-                message: variable.description,
-                initialValue: variable.default === true,
-            });
-            if (isCancel(response)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            responses[variable.name] = response;
-        }
-    }
-    return responses;
-}
+import { CODE_ROUTER, FILE_ROUTER, finalizeAddOns, getFrameworkById, getPackageManager, } from '@tanstack/cta-engine';
+import { getProjectName, selectAddOns, selectGit, selectPackageManager, selectRouterType, selectTailwind, selectToolchain, selectTypescript, } from './ui-prompts.js';
 export async function promptForOptions(cliOptions, { forcedAddOns = [], forcedMode, }) {
     const options = {};
-    const framework = getFrameworkById(cliOptions.framework || 'react-cra');
-    options.framework = framework;
-    // TODO: This is a bit of a hack to ensure that the framework is solid
-    if (options.framework.id === 'solid') {
-        options.typescript = true;
-        options.tailwind = true;
-    }
-    if (cliOptions.addOns) {
-        options.typescript = true;
-    }
-    if (!cliOptions.projectName) {
-        const value = await text({
-            message: 'What would you like to name your project?',
-            defaultValue: 'my-app',
-            validate(value) {
-                if (!value) {
-                    return 'Please enter a name';
-                }
-            },
-        });
-        if (isCancel(value)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.projectName = value;
-    }
-    else {
-        options.projectName = cliOptions.projectName;
-    }
+    options.framework = getFrameworkById(cliOptions.framework || 'react-cra');
+    options.projectName = cliOptions.projectName || (await getProjectName());
     // Router type selection
-    if (!cliOptions.template && !forcedMode) {
-        const routerType = await select({
-            message: 'Select the router type:',
-            options: [
-                {
-                    value: FILE_ROUTER,
-                    label: 'File Router - File-based routing structure',
-                },
-                {
-                    value: CODE_ROUTER,
-                    label: 'Code Router - Traditional code-based routing',
-                },
-            ],
-            initialValue: FILE_ROUTER,
-        });
-        if (isCancel(routerType)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.mode = routerType;
+    if (forcedMode) {
+        options.mode = forcedMode;
     }
-    else if (forcedMode) {
-        options.mode = forcedMode === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
-        options.typescript = options.mode === FILE_ROUTER;
-    }
-    else {
+    else if (cliOptions.template) {
         options.mode =
             cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
-        if (options.mode === FILE_ROUTER) {
-            options.typescript = true;
-        }
+    }
+    else {
+        options.mode = await selectRouterType();
     }
     // TypeScript selection (if using Code Router)
-    if (!options.typescript) {
-        if (options.mode === CODE_ROUTER) {
-            const typescriptEnable = await confirm({
-                message: 'Would you like to use TypeScript?',
-                initialValue: true,
-            });
-            if (isCancel(typescriptEnable)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            options.typescript = typescriptEnable;
-        }
-        else {
-            options.typescript = true;
-        }
+    options.typescript =
+        options.mode === FILE_ROUTER || options.framework.id === 'solid';
+    if (!options.typescript && options.mode === CODE_ROUTER) {
+        options.typescript = await selectTypescript();
     }
     // Tailwind selection
     if (!cliOptions.tailwind && options.framework.id === 'react-cra') {
-        const tailwind = await confirm({
-            message: 'Would you like to use Tailwind CSS?',
-            initialValue: true,
-        });
-        if (isCancel(tailwind)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.tailwind = tailwind;
+        options.tailwind = await selectTailwind();
     }
     else {
-        // TODO: This is a bit of a hack to ensure that the framework is solid
-        options.tailwind = options.framework.id === 'solid' || !!cliOptions.tailwind;
+        options.tailwind = true;
     }
     // Package manager selection
-    if (cliOptions.packageManager === undefined) {
-        const detectedPackageManager = getPackageManager();
-        if (!detectedPackageManager) {
-            const pm = await select({
-                message: 'Select package manager:',
-                options: SUPPORTED_PACKAGE_MANAGERS.map((pm) => ({
-                    value: pm,
-                    label: pm,
-                })),
-                initialValue: DEFAULT_PACKAGE_MANAGER,
-            });
-            if (isCancel(pm)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            options.packageManager = pm;
-        }
-        else {
-            options.packageManager = detectedPackageManager;
-        }
+    if (cliOptions.packageManager) {
+        options.packageManager = cliOptions.packageManager;
     }
     else {
-        options.packageManager = cliOptions.packageManager;
+        const detectedPackageManager = await getPackageManager();
+        options.packageManager =
+            detectedPackageManager || (await selectPackageManager());
     }
     // Toolchain selection
-    let toolchain = undefined;
-    if (cliOptions.toolchain === undefined) {
-        const toolchains = new Set();
-        for (const addOn of framework.getAddOns()) {
-            if (addOn.type === 'toolchain') {
-                toolchains.add(addOn);
-            }
-        }
-        const tc = await select({
-            message: 'Select toolchain',
-            options: [
-                {
-                    value: undefined,
-                    label: 'None',
-                },
-                ...Array.from(toolchains).map((tc) => ({
-                    value: tc,
-                    label: tc.name,
-                })),
-            ],
-            initialValue: undefined,
-        });
-        if (isCancel(tc)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        toolchain = tc;
+    const toolchain = await selectToolchain(options.framework, cliOptions.toolchain);
+    // Add-ons selection
+    const addOns = new Set();
+    if (toolchain) {
+        addOns.add(toolchain);
     }
-    else {
-        for (const addOn of framework.getAddOns()) {
-            if (addOn.type === 'toolchain' && addOn.id === cliOptions.toolchain) {
-                toolchain = addOn;
-            }
-        }
+    for (const addOn of forcedAddOns) {
+        addOns.add(addOn);
     }
-    options.chosenAddOns = toolchain ? [toolchain] : [];
     if (Array.isArray(cliOptions.addOns)) {
-        options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, Array.from(new Set([...cliOptions.addOns, ...forcedAddOns, toolchain?.id])).filter(Boolean));
-        options.tailwind = true;
-    }
-    else if (cliOptions.addOns) {
-        // Select any add-ons
-        const allAddOns = await getAllAddOns(options.framework, options.mode);
-        const addOns = allAddOns.filter((addOn) => addOn.type === 'add-on');
-        let selectedAddOns = [];
-        if (options.typescript && addOns.length > 0) {
-            const value = await multiselect({
-                message: 'What add-ons would you like for your project:',
-                options: addOns
-                    .filter((addOn) => !forcedAddOns.includes(addOn.id))
-                    .map((addOn) => ({
-                    value: addOn.id,
-                    label: addOn.name,
-                    hint: addOn.description,
-                })),
-                required: false,
-            });
-            if (isCancel(value)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            selectedAddOns = value;
-        }
-        // Select any examples
-        let selectedExamples = [];
-        const examples = allAddOns.filter((addOn) => addOn.type === 'example');
-        if (options.typescript && examples.length > 0) {
-            const value = await multiselect({
-                message: 'Would you like any examples?',
-                options: examples
-                    .filter((addOn) => !forcedAddOns.includes(addOn.id))
-                    .map((addOn) => ({
-                    value: addOn.id,
-                    label: addOn.name,
-                    hint: addOn.description,
-                })),
-                required: false,
-            });
-            if (isCancel(value)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            selectedExamples = value;
-        }
-        if (selectedAddOns.length > 0 ||
-            selectedExamples.length > 0 ||
-            forcedAddOns.length > 0 ||
-            toolchain) {
-            options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, Array.from(new Set([
-                ...selectedAddOns,
-                ...selectedExamples,
-                ...forcedAddOns,
-                toolchain?.id,
-            ])).filter(Boolean));
-            options.tailwind = true;
+        for (const addOn of cliOptions.addOns) {
+            addOns.add(addOn);
         }
     }
-    else if (forcedAddOns.length > 0) {
-        options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, Array.from(new Set([...forcedAddOns, toolchain?.id])).filter(Boolean));
-    }
-    // Collect variables
-    const variables = [];
-    for (const addOn of options.chosenAddOns) {
-        for (const variable of addOn.variables ?? []) {
-            variables.push(variable);
+    else {
+        for (const addOn of await selectAddOns(options.framework, options.mode, 'add-on', 'What add-ons would you like for your project?', forcedAddOns)) {
+            addOns.add(addOn);
         }
-    }
-    options.variableValues = await collectVariables(variables);
-    // Git selection
-    if (cliOptions.git === undefined) {
-        const git = await confirm({
-            message: 'Would you like to initialize a new git repository?',
-            initialValue: true,
-        });
-        if (isCancel(git)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
+        for (const addOn of await selectAddOns(options.framework, options.mode, 'example', 'Would you like any examples?', forcedAddOns)) {
+            addOns.add(addOn);
         }
-        options.git = git;
     }
-    else {
-        options.git = !!cliOptions.git;
+    options.chosenAddOns = Array.from(await finalizeAddOns(options.framework, options.mode, Array.from(addOns)));
+    if (options.chosenAddOns.length) {
+        options.tailwind = true;
+        options.typescript = true;
     }
+    options.git = cliOptions.git || (await selectGit());
     return options;
 }

package/dist/types/cli.d.ts

@@ -1,7 +1,9 @@
 import type { Mode } from '@tanstack/cta-engine';
-export declare function cli({ name, appName, forcedMode, forcedAddOns, }: {
+import type { TemplateOptions } from './types.js';
+export declare function cli({ name, appName, forcedMode, forcedAddOns, defaultTemplate, }: {
     name: string;
     appName: string;
     forcedMode?: Mode;
     forcedAddOns?: Array<string>;
+    defaultTemplate?: TemplateOptions;
 }): void;

package/dist/types/command-line.d.ts

@@ -0,0 +1,3 @@
+import type { Mode, Options } from '@tanstack/cta-engine';
+import type { CliOptions } from './types.js';
+export declare function normalizeOptions(cliOptions: CliOptions, forcedMode?: Mode, forcedAddOns?: Array<string>): Promise<Options | undefined>;

package/dist/types/mcp.d.ts

@@ -0,0 +1,7 @@
+import type { Mode } from '@tanstack/cta-engine';
+export declare function runMCPServer(sse: boolean, { forcedAddOns, appName, name, }: {
+    forcedMode?: Mode;
+    forcedAddOns?: Array<string>;
+    appName?: string;
+    name?: string;
+}): Promise<void>;

package/dist/types/options.d.ts

@@ -1,7 +1,6 @@
-import type { Mode, Options, TemplateOptions } from '@tanstack/cta-engine';
+import type { Mode, Options } from '@tanstack/cta-engine';
 import type { CliOptions } from './types.js';
-export declare function normalizeOptions(cliOptions: CliOptions, forcedMode?: Mode, forcedAddOns?: Array<string>): Promise<Options | undefined>;
 export declare function promptForOptions(cliOptions: CliOptions, { forcedAddOns, forcedMode, }: {
     forcedAddOns?: Array<string>;
-    forcedMode?: TemplateOptions;
+    forcedMode?: Mode;
 }): Promise<Required<Options> | undefined>;

package/dist/types/types.d.ts

@@ -1,4 +1,5 @@
-import type { PackageManager, TemplateOptions } from '@tanstack/cta-engine';
+import type { PackageManager } from '@tanstack/cta-engine';
+export type TemplateOptions = 'typescript' | 'javascript' | 'file-router';
 export interface CliOptions {
     template?: TemplateOptions;
     framework?: string;
@@ -14,4 +15,5 @@ export interface CliOptions {
     starter?: string;
     targetDir?: string;
     interactive?: boolean;
+    ui?: boolean;
 }

package/dist/types/ui-environment.d.ts

@@ -1,2 +1,2 @@
 import type { Environment } from '@tanstack/cta-engine';
-export declare function createUIEnvironment(): Environment;
+export declare function createUIEnvironment(appName: string, silent: boolean): Environment;

package/dist/types/ui-prompts.d.ts

@@ -0,0 +1,10 @@
+import type { Mode, PackageManager } from '@tanstack/cta-engine';
+import type { Framework } from '@tanstack/cta-engine/dist/types/types.js';
+export declare function getProjectName(): Promise<string>;
+export declare function selectRouterType(): Promise<Mode>;
+export declare function selectTypescript(): Promise<boolean>;
+export declare function selectTailwind(): Promise<boolean>;
+export declare function selectPackageManager(): Promise<PackageManager>;
+export declare function selectAddOns(framework: Framework, mode: Mode, type: string, message: string, forcedAddOns?: Array<string>): Promise<Array<string>>;
+export declare function selectGit(): Promise<boolean>;
+export declare function selectToolchain(framework: Framework, toolchain?: string): Promise<string | undefined>;

package/dist/types/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Mode } from '@tanstack/cta-engine';
+import type { TemplateOptions } from './types.js';
+export declare function convertTemplateToMode(template: TemplateOptions): Mode;

package/dist/ui-environment.js

@@ -1,49 +1,52 @@
 import { cancel, confirm, intro, isCancel, log, outro, spinner, } from '@clack/prompts';
 import chalk from 'chalk';
 import { createDefaultEnvironment } from '@tanstack/cta-engine';
-export function createUIEnvironment() {
+export function createUIEnvironment(appName, silent) {
     const defaultEnvironment = createDefaultEnvironment();
-    return {
+    let newEnvironment = {
         ...defaultEnvironment,
-        intro: (message) => {
-            intro(message);
-        },
-        outro: (message) => {
-            outro(message);
-        },
-        info: (title, message) => {
-            console.log('info', title, message);
-            log.info(`${title ? chalk.red(title) : ''}${message ? chalk.green(message) : ''}`);
-        },
-        error: (title, message) => {
-            console.log('error', title, message);
-            log.error(`${title ? `${title}: ` : ''}${message}`);
-        },
-        warn: (title, message) => {
-            console.log('warn', title, message);
-            log.warn(`${title ? `${title}: ` : ''}${message}`);
-        },
-        confirm: async (message) => {
-            console.log('confirm', message);
-            const shouldContinue = await confirm({
-                message,
-            });
-            if (isCancel(shouldContinue)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            return shouldContinue;
-        },
-        spinner: () => {
-            const s = spinner();
-            return {
-                start: (message) => {
-                    s.start(message);
-                },
-                stop: (message) => {
-                    s.stop(message);
-                },
-            };
-        },
+        appName,
     };
+    if (!silent) {
+        newEnvironment = {
+            ...newEnvironment,
+            intro: (message) => {
+                intro(message);
+            },
+            outro: (message) => {
+                outro(message);
+            },
+            info: (title, message) => {
+                log.info(`${title ? chalk.red(title) : ''}${message ? '\n' + chalk.green(message) : ''}`);
+            },
+            error: (title, message) => {
+                log.error(`${title ? `${title}: ` : ''}${message ? '\n' + message : ''}`);
+            },
+            warn: (title, message) => {
+                log.warn(`${title ? `${title}: ` : ''}${message ? '\n' + message : ''}`);
+            },
+            confirm: async (message) => {
+                const shouldContinue = await confirm({
+                    message,
+                });
+                if (isCancel(shouldContinue)) {
+                    cancel('Operation cancelled.');
+                    process.exit(0);
+                }
+                return shouldContinue;
+            },
+            spinner: () => {
+                const s = spinner();
+                return {
+                    start: (message) => {
+                        s.start(message);
+                    },
+                    stop: (message) => {
+                        s.stop(message);
+                    },
+                };
+            },
+        };
+    }
+    return newEnvironment;
 }