@tanstack/cta-engine 0.10.0-alpha.6

package/dist/options.js

@@ -0,0 +1,309 @@
+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) {
+    // 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) {
+            addOns = true;
+            let finalAddOns = [...(overlay?.dependsOn || [])];
+            if (cliOptions.addOns && Array.isArray(cliOptions.addOns)) {
+                finalAddOns = [...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: {},
+            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) {
+    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) {
+        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 {
+        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, cliOptions.addOns);
+        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.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.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) {
+            options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, [...selectedAddOns, ...selectedExamples]);
+            options.tailwind = true;
+        }
+    }
+    // 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

@@ -0,0 +1,30 @@
+export const SUPPORTED_PACKAGE_MANAGERS = [
+    'npm',
+    'yarn',
+    'pnpm',
+    'bun',
+    'deno',
+];
+export const DEFAULT_PACKAGE_MANAGER = 'npm';
+export function getPackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent === undefined) {
+        return DEFAULT_PACKAGE_MANAGER;
+    }
+    const packageManager = SUPPORTED_PACKAGE_MANAGERS.find((manager) => userAgent.startsWith(manager));
+    return packageManager;
+}
+export function packageManagerExecute(environment, packagerManager, pkg, args, cwd) {
+    switch (packagerManager) {
+        case 'yarn':
+            return environment.execute('yarn', ['dlx', pkg, ...args], cwd);
+        case 'pnpm':
+            return environment.execute('pnpx', [pkg, ...args], cwd);
+        case 'bun':
+            return environment.execute('bunx', ['--bun', pkg, ...args], cwd);
+        case 'deno':
+            return environment.execute('deno', ['run', `npm:${pkg}`, ...args], cwd);
+        default:
+            return environment.execute('npx', [pkg, ...args], 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

@@ -0,0 +1,5 @@
+import type { AddOn, CliOptions, Framework } 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 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 @@
+export declare function cli(): void;

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

@@ -0,0 +1,7 @@
+import type { Environment, Options } from './types';
+export type PersistedOptions = Exclude<Partial<Options>, 'addOns' | 'chosenAddOns'> & {
+    version: number;
+    existingAddOns: Array<string>;
+};
+export declare function writeConfigFile(environment: Environment, targetDir: string, options: Options): Promise<void>;
+export declare function readConfigFile(targetDir: string): Promise<PersistedOptions | null>;

package/dist/types/constants.d.ts

@@ -0,0 +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/create-app.d.ts

@@ -0,0 +1,6 @@
+import type { Environment, Options } from './types.js';
+export declare function createApp(options: Options, { silent, environment, cwd, }: {
+    silent?: boolean;
+    environment: Environment;
+    cwd?: string;
+}): Promise<void>;

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/environment.d.ts

@@ -0,0 +1,12 @@
+import type { Environment } from './types.js';
+export declare function createDefaultEnvironment(): Environment;
+export declare function createMemoryEnvironment(): {
+    environment: Environment;
+    output: {
+        files: Record<string, string>;
+        commands: Array<{
+            command: string;
+            args: Array<string>;
+        }>;
+    };
+};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { cli } from './cli.js';

package/dist/types/mcp.d.ts

@@ -0,0 +1 @@
+export default function runServer(sse: boolean): Promise<void>;

package/dist/types/options.d.ts

@@ -0,0 +1,3 @@
+import type { CliOptions, Options } from './types.js';
+export declare function normalizeOptions(cliOptions: CliOptions): Promise<Options | undefined>;
+export declare function promptForOptions(cliOptions: CliOptions): Promise<Required<Options>>;

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

@@ -0,0 +1,6 @@
+import type { Environment } from './types.js';
+export declare const SUPPORTED_PACKAGE_MANAGERS: readonly ["npm", "yarn", "pnpm", "bun", "deno"];
+export type PackageManager = (typeof SUPPORTED_PACKAGE_MANAGERS)[number];
+export declare const DEFAULT_PACKAGE_MANAGER: PackageManager;
+export declare function getPackageManager(): PackageManager | undefined;
+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;

package/dist/types/types.d.ts

@@ -0,0 +1,107 @@
+import type { CODE_ROUTER, FILE_ROUTER } from './constants.js';
+import type { PackageManager } from './package-manager.js';
+import type { ToolChain } from './toolchain.js';
+export type Framework = 'solid' | 'react';
+export interface Options {
+    framework: Framework;
+    projectName: string;
+    typescript: boolean;
+    tailwind: boolean;
+    packageManager: PackageManager;
+    toolchain: ToolChain;
+    mode: typeof CODE_ROUTER | typeof FILE_ROUTER;
+    addOns: boolean;
+    chosenAddOns: Array<AddOn>;
+    git: boolean;
+    variableValues: Record<string, string | number | boolean>;
+    overlay?: AddOn | undefined;
+}
+export interface CliOptions {
+    template?: 'typescript' | 'javascript' | 'file-router';
+    framework?: Framework;
+    tailwind?: boolean;
+    packageManager?: PackageManager;
+    toolchain?: ToolChain;
+    projectName?: string;
+    git?: boolean;
+    addOns?: Array<string> | boolean;
+    listAddOns?: boolean;
+    mcp?: boolean;
+    mcpSse?: boolean;
+    overlay?: string;
+    targetDir?: string;
+}
+export type Environment = {
+    startRun: () => void;
+    finishRun: () => void;
+    getErrors: () => Array<string>;
+    appendFile: (path: string, contents: string) => Promise<void>;
+    copyFile: (from: string, to: string) => Promise<void>;
+    writeFile: (path: string, contents: string) => Promise<void>;
+    execute: (command: string, args: Array<string>, cwd: string) => Promise<void>;
+    deleteFile: (path: string) => Promise<void>;
+    readFile: (path: string, encoding?: BufferEncoding) => Promise<string>;
+    exists: (path: string) => boolean;
+    readdir: (path: string) => Array<string>;
+    isDirectory: (path: string) => boolean;
+};
+type BooleanVariable = {
+    name: string;
+    default: boolean;
+    description: string;
+    type: 'boolean';
+};
+type NumberVariable = {
+    name: string;
+    default: number;
+    description: string;
+    type: 'number';
+};
+type StringVariable = {
+    name: string;
+    default: string;
+    description: string;
+    type: 'string';
+};
+export type Variable = BooleanVariable | NumberVariable | StringVariable;
+export type AddOn = {
+    id: string;
+    name: string;
+    description: string;
+    type: 'add-on' | 'example' | 'overlay';
+    link: string;
+    templates: Array<string>;
+    routes: Array<{
+        url: string;
+        name: string;
+    }>;
+    packageAdditions: {
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+        scripts?: Record<string, string>;
+    };
+    command?: {
+        command: string;
+        args?: Array<string>;
+    };
+    readme?: string;
+    phase: 'setup' | 'add-on';
+    shadcnComponents?: Array<string>;
+    warning?: string;
+    dependsOn?: Array<string>;
+    variables?: Array<Variable>;
+    files?: Record<string, string>;
+    deletedFiles?: Array<string>;
+};
+export type Overlay = AddOn & {
+    type: 'overlay';
+    version: string;
+    author: string;
+    link: string;
+    license: string;
+    mode: typeof CODE_ROUTER | typeof FILE_ROUTER;
+    framework: Framework;
+    typescript: boolean;
+    tailwind: boolean;
+};
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function sortObject(obj: Record<string, string>): Record<string, string>;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,8 @@
+export function sortObject(obj) {
+    return Object.keys(obj)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = obj[key];
+        return acc;
+    }, {});
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@tanstack/cta-engine",
+  "version": "0.10.0-alpha.6",
+  "description": "Tanstack Application Builder Engine",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TanStack/create-tsrouter-app.git"
+  },
+  "homepage": "https://tanstack.com/router",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "keywords": [
+    "react",
+    "tanstack",
+    "router",
+    "create-react-app"
+  ],
+  "author": "Jack Herrington <jherr@pobox.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "@modelcontextprotocol/sdk": "^1.6.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ejs": "^3.1.10",
+    "execa": "^9.5.2",
+    "express": "^4.21.2",
+    "memfs": "^4.17.0",
+    "prettier": "^3.5.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@tanstack/config": "^0.16.2",
+    "@types/ejs": "^3.1.5",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.13.4",
+    "eslint": "^9.20.0",
+    "eslint-plugin-react-hooks": "^5.1.0",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "typescript": "^5.6.3",
+    "vitest": "^3.0.8"
+  },
+  "scripts": {}
+}