@tanstack/cta-engine 0.10.0-alpha.15 → 0.10.0-alpha.16

package/dist/options.js

@@ -1,328 +0,0 @@
-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, loadRemoteAddOn } from './add-ons.js';
-// If all CLI options are provided, use them directly
-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.
-    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) {
-            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,
-                ]));
-            }
-            chosenAddOns = await finalizeAddOns(cliOptions.framework || DEFAULT_FRAMEWORK, cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER, finalAddOns);
-            tailwind = true;
-            typescript = true;
-        }
-        return {
-            framework: cliOptions.framework || 'react',
-            projectName: cliOptions.projectName,
-            typescript,
-            tailwind,
-            packageManager: cliOptions.packageManager ||
-                getPackageManager() ||
-                DEFAULT_PACKAGE_MANAGER,
-            toolchain: cliOptions.toolchain || DEFAULT_TOOLCHAIN,
-            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;
-}
-export async function promptForOptions(cliOptions, { forcedAddOns = [], forcedMode, }) {
-    const options = {};
-    options.framework = cliOptions.framework || DEFAULT_FRAMEWORK;
-    if (options.framework === '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;
-    }
-    // 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;
-    }
-    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;
-        if (options.mode === FILE_ROUTER) {
-            options.typescript = true;
-        }
-    }
-    // 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;
-        }
-    }
-    // Tailwind selection
-    if (!cliOptions.tailwind && options.framework === 'react') {
-        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;
-    }
-    else {
-        options.tailwind = options.framework === 'solid' || !!cliOptions.tailwind;
-    }
-    // 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;
-        }
-    }
-    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, Array.from(new Set([...cliOptions.addOns, ...forcedAddOns])));
-        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) {
-            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) {
-        for (const variable of addOn.variables ?? []) {
-            variables.push(variable);
-        }
-    }
-    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);
-        }
-        options.git = git;
-    }
-    else {
-        options.git = !!cliOptions.git;
-    }
-    return options;
-}

package/dist/templates.js

@@ -1,6 +0,0 @@
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-export function getTemplatesRoot() {
-    // Get the parent directory because the compiled code is in the dist folder
-    return join(dirname(dirname(fileURLToPath(import.meta.url))), 'templates');
-}

package/dist/toolchain.js

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

package/dist/types/add.d.ts

@@ -1,3 +0,0 @@
-export declare function add(addOns: Array<string>, { silent, }?: {
-    silent?: boolean;
-}): Promise<void>;

package/dist/types/cli.d.ts

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

package/dist/types/custom-add-on.d.ts

@@ -1,6 +0,0 @@
-import type { Options } from './types.js';
-import type { PersistedOptions } from './config-file.js';
-type AddOnMode = 'add-on' | 'starter';
-export declare function createAppOptionsFromPersisted(json: PersistedOptions): Promise<Required<Options>>;
-export declare function initAddOn(mode: AddOnMode): Promise<void>;
-export {};

package/dist/types/file-helper.d.ts

@@ -1,2 +0,0 @@
-export declare function readFileHelper(path: string): string;
-export declare function getBinaryFile(content: string): string | null;

package/dist/types/mcp.d.ts

@@ -1,7 +0,0 @@
-import type { TemplateOptions } from './types.js';
-export default function runServer(sse: boolean, { forcedAddOns, appName, name, }: {
-    forcedMode?: TemplateOptions;
-    forcedAddOns?: Array<string>;
-    appName?: string;
-    name?: string;
-}): Promise<void>;

package/dist/types/options.d.ts

@@ -1,6 +0,0 @@
-import type { CliOptions, Options } from './types.js';
-export declare function normalizeOptions(cliOptions: CliOptions, forcedAddOns?: Array<string>): Promise<Options | undefined>;
-export declare function promptForOptions(cliOptions: CliOptions, { forcedAddOns, forcedMode, }: {
-    forcedAddOns?: Array<string>;
-    forcedMode?: 'typescript' | 'javascript' | 'file-router';
-}): Promise<Required<Options>>;

package/dist/types/templates.d.ts

@@ -1 +0,0 @@
-export declare function getTemplatesRoot(): string;

package/dist/types/toolchain.d.ts

@@ -1,3 +0,0 @@
-export declare const SUPPORTED_TOOLCHAINS: readonly ["none", "biome", "eslint+prettier"];
-export type ToolChain = (typeof SUPPORTED_TOOLCHAINS)[number];
-export declare const DEFAULT_TOOLCHAIN: ToolChain;

package/src/cli.ts

@@ -1,196 +0,0 @@
-import { Command, InvalidArgumentError } from 'commander'
-import { intro, log } from '@clack/prompts'
-
-import { createApp } from './create-app.js'
-import { normalizeOptions, promptForOptions } from './options.js'
-import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager.js'
-import { 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 { initAddOn } from './custom-add-on.js'
-
-import { createDefaultEnvironment } from './environment.js'
-import { add } from './add.js'
-
-import type { PackageManager } from './package-manager.js'
-import type { ToolChain } from './toolchain.js'
-import type { CliOptions, Framework } from './types.js'
-
-export function cli({
-  name,
-  appName,
-  forcedMode,
-  forcedAddOns,
-}: {
-  name: string
-  appName: string
-  forcedMode?: 'typescript' | 'javascript' | 'file-router'
-  forcedAddOns?: Array<string>
-}) {
-  const program = new Command()
-
-  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)')
-    .action(async (addOn: string) => {
-      await add(addOn.split(',').map((addon) => addon.trim()))
-    })
-
-  program
-    .command('update-add-on')
-    .description('Create or update an add-on from the current project')
-    .action(async () => {
-      await initAddOn('add-on')
-    })
-
-  program
-    .command('update-starter')
-    .description('Create or update a project starter from the current project')
-    .action(async () => {
-      await initAddOn('starter')
-    })
-
-  program.argument('[project-name]', 'name of the project')
-
-  if (!forcedMode) {
-    program.option<'typescript' | 'javascript' | 'file-router'>(
-      '--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>(
-      '--framework <type>',
-      'project framework (solid, react)',
-      (value) => {
-        if (!SUPPORTED_FRAMEWORKS.includes(value as Framework)) {
-          throw new InvalidArgumentError(
-            `Invalid framework: ${value}. Only the following are allowed: ${SUPPORTED_FRAMEWORKS.join(
-              ', ',
-            )}`,
-          )
-        }
-        return value as Framework
-      },
-      DEFAULT_FRAMEWORK,
-    )
-    .option(
-      '--starter [url]',
-      'initialize this project from a starter URL',
-      false,
-    )
-    .option<PackageManager>(
-      `--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`,
-      `Explicitly tell the CLI to use this package manager`,
-      (value) => {
-        if (!SUPPORTED_PACKAGE_MANAGERS.includes(value as PackageManager)) {
-          throw new InvalidArgumentError(
-            `Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(
-              ', ',
-            )}`,
-          )
-        }
-        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]',
-      'pick from a list of available add-ons (comma separated list)',
-      (value: string) => {
-        let addOns: Array<string> | boolean = !!value
-        if (typeof value === 'string') {
-          addOns = value.split(',').map((addon) => addon.trim())
-        }
-        return addOns
-      },
-    )
-    .option('--list-add-ons', 'list all available add-ons', false)
-    .option('--no-git', 'do not create a git repository')
-    .option(
-      '--target-dir <path>',
-      'the target directory for the application root',
-    )
-    .option('--mcp', 'run the MCP server', false)
-    .option('--mcp-sse', 'run the MCP server in SSE mode', false)
-
-  program.action(async (projectName: string, options: CliOptions) => {
-    if (options.listAddOns) {
-      await listAddOns(options, {
-        forcedMode,
-        forcedAddOns,
-      })
-    } else if (options.mcp || options.mcpSse) {
-      await runServer(!!options.mcpSse, {
-        forcedMode,
-        forcedAddOns,
-        appName,
-      })
-    } else {
-      try {
-        const cliOptions = {
-          projectName,
-          ...options,
-        } as CliOptions
-
-        if (forcedMode) {
-          cliOptions.template = forcedMode
-        }
-
-        let finalOptions = await normalizeOptions(cliOptions, forcedAddOns)
-        if (finalOptions) {
-          intro(`Creating a new ${appName} app in ${projectName}...`)
-        } else {
-          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',
-        )
-        process.exit(1)
-      }
-    }
-  })
-
-  program.parse()
-}