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

package/dist/options.js

@@ -0,0 +1,330 @@
+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, 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 overlay = cliOptions.overlay
+            ? (await loadRemoteAddOn(cliOptions.overlay))
+            : undefined;
+        if (overlay) {
+            tailwind = overlay.tailwind;
+            typescript = overlay.typescript;
+            cliOptions.framework = overlay.framework;
+            mode = overlay.mode;
+        }
+        let addOns = false;
+        let chosenAddOns = [];
+        if (Array.isArray(cliOptions.addOns) ||
+            overlay?.dependsOn ||
+            forcedAddOns) {
+            addOns = true;
+            let finalAddOns = Array.from(new Set([...(overlay?.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, forcedMode || 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: {},
+            overlay,
+        };
+    }
+}
+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/package-manager.js

@@ -14,62 +14,17 @@ export function getPackageManager() {
     const packageManager = SUPPORTED_PACKAGE_MANAGERS.find((manager) => userAgent.startsWith(manager));
     return packageManager;
 }
-export function getPackageManagerScriptCommand(packagerManager, args = []) {
+export function packageManagerExecute(environment, packagerManager, pkg, args, cwd) {
     switch (packagerManager) {
         case 'yarn':
-            return { command: 'yarn', args: ['run', ...args] };
+            return environment.execute('yarn', ['dlx', pkg, ...args], cwd);
         case 'pnpm':
-            return { command: 'pnpm', args: [...args] };
+            return environment.execute('pnpx', [pkg, ...args], cwd);
         case 'bun':
-            return { command: 'bunx', args: ['--bun', 'run', ...args] };
+            return environment.execute('bunx', ['--bun', pkg, ...args], cwd);
         case 'deno':
-            return { command: 'deno', args: ['task', ...args] };
+            return environment.execute('deno', ['run', `npm:${pkg}`, ...args], cwd);
         default:
-            return { command: 'npm', args: ['run', ...args] };
+            return environment.execute('npx', [pkg, ...args], cwd);
     }
 }
-export function getPackageManagerExecuteCommand(packagerManager, pkg, args = []) {
-    switch (packagerManager) {
-        case 'yarn':
-            return { command: 'yarn', args: ['dlx', pkg, ...args] };
-        case 'pnpm':
-            return { command: 'pnpx', args: [pkg, ...args] };
-        case 'bun':
-            return { command: 'bunx', args: ['--bun', pkg, ...args] };
-        case 'deno':
-            return { command: 'deno', args: ['run', `npm:${pkg}`, ...args] };
-        default:
-            return { command: 'npx', args: [pkg, ...args] };
-    }
-}
-export function getPackageManagerInstallCommand(packagerManager, pkg, isDev = false) {
-    if (pkg) {
-        switch (packagerManager) {
-            case 'yarn':
-            case 'pnpm':
-                return {
-                    command: packagerManager,
-                    args: ['add', pkg, isDev ? '--dev' : ''],
-                };
-            default:
-                return {
-                    command: packagerManager,
-                    args: ['install', pkg, isDev ? '-D' : ''],
-                };
-        }
-    }
-    else {
-        return {
-            command: packagerManager,
-            args: ['install'],
-        };
-    }
-}
-export function packageManagerInstall(environment, cwd, packagerManager, pkg) {
-    const { command, args: commandArgs } = getPackageManagerInstallCommand(packagerManager, pkg);
-    return environment.execute(command, commandArgs, cwd);
-}
-export function packageManagerExecute(environment, cwd, packagerManager, pkg, args) {
-    const { command, args: commandArgs } = getPackageManagerExecuteCommand(packagerManager, pkg, args);
-    return environment.execute(command, commandArgs, cwd);
-}

package/dist/templates.js

@@ -0,0 +1,6 @@
+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

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

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

@@ -1,4 +1,8 @@
-import type { AddOn, Framework } from './types.js';
-export declare function getAllAddOns(framework: Framework, template: string): Array<AddOn>;
+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, { forcedMode, forcedAddOns, }: {
+    forcedMode?: TemplateOptions;
+    forcedAddOns?: Array<string>;
+}): Promise<void>;
 export declare function loadRemoteAddOn(url: string): Promise<AddOn>;

package/dist/types/add.d.ts

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

package/dist/types/cli.d.ts

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

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

@@ -1,6 +1,5 @@
-import type { Environment, Options } from './types.js';
-export type PersistedOptions = Omit<Partial<Options>, 'addOns' | 'chosenAddOns' | 'framework'> & {
-    framework: string;
+import type { Environment, Options } from './types';
+export type PersistedOptions = Exclude<Partial<Options>, 'addOns' | 'chosenAddOns'> & {
     version: number;
     existingAddOns: Array<string>;
 };

package/dist/types/constants.d.ts

@@ -1,3 +1,6 @@
+import type { Framework } from './types.js';
 export declare const CODE_ROUTER = "code-router";
 export declare const FILE_ROUTER = "file-router";
+export declare const SUPPORTED_FRAMEWORKS: Array<Framework>;
+export declare const DEFAULT_FRAMEWORK: Framework;
 export declare const CONFIG_FILE = ".cta.json";

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

@@ -0,0 +1,3 @@
+type AddOnMode = 'add-on' | 'overlay';
+export declare function initAddOn(mode: AddOnMode): Promise<void>;
+export {};

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

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

package/dist/types/index.d.ts

@@ -1,13 +1 @@
-export { createApp } from './create-app.js';
-export { addToApp } from './add-to-app.js';
-export { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.js';
-export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';
-export { CODE_ROUTER, CONFIG_FILE, FILE_ROUTER } from './constants.js';
-export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, getPackageManagerInstallCommand, getPackageManagerExecuteCommand, getPackageManagerScriptCommand, packageManagerInstall, packageManagerExecute, } from './package-manager.js';
-export { registerFramework, getFrameworkById, getFrameworkByName, getFrameworks, } from './frameworks.js';
-export { formatCommand, jsSafeName, sortObject } from './utils.js';
-export { writeConfigFile, readConfigFile } from './config-file.js';
-export { readFileHelper, getBinaryFile, relativePath } from './file-helpers.js';
-export type { AddOn, Environment, FileBundleHandler, FrameworkDefinition, Mode, Options, Starter, TemplateOptions, Variable, } from './types.js';
-export type { PersistedOptions } from './config-file.js';
-export type { PackageManager } from './package-manager.js';
+export { cli } from './cli.js';

package/dist/types/mcp.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,6 @@
+import type { CliOptions, Mode, Options, TemplateOptions } 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;
+}): Promise<Required<Options>>;

package/dist/types/package-manager.d.ts

@@ -3,17 +3,4 @@ export declare const SUPPORTED_PACKAGE_MANAGERS: readonly ["npm", "yarn", "pnpm"
 export type PackageManager = (typeof SUPPORTED_PACKAGE_MANAGERS)[number];
 export declare const DEFAULT_PACKAGE_MANAGER: PackageManager;
 export declare function getPackageManager(): PackageManager | undefined;
-export declare function getPackageManagerScriptCommand(packagerManager: PackageManager, args?: Array<string>): {
-    command: string;
-    args: string[];
-};
-export declare function getPackageManagerExecuteCommand(packagerManager: PackageManager, pkg: string, args?: Array<string>): {
-    command: string;
-    args: string[];
-};
-export declare function getPackageManagerInstallCommand(packagerManager: PackageManager, pkg?: string, isDev?: boolean): {
-    command: "npm" | "yarn" | "pnpm" | "bun" | "deno";
-    args: string[];
-};
-export declare function packageManagerInstall(environment: Environment, cwd: string, packagerManager: PackageManager, pkg?: string): Promise<void>;
-export declare function packageManagerExecute(environment: Environment, cwd: string, packagerManager: PackageManager, pkg: string, args: Array<string>): Promise<void>;
+export declare function packageManagerExecute(environment: Environment, packagerManager: PackageManager, pkg: string, args: Array<string>, cwd: string): Promise<void>;

package/dist/types/templates.d.ts

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

package/dist/types/toolchain.d.ts

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