@tanstack/cli 0.0.8 → 0.48.3

package/dist/types/mcp/types.d.ts

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+export declare const LibrarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    tagline: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    frameworks: z.ZodArray<z.ZodString, "many">;
+    latestVersion: z.ZodString;
+    latestBranch: z.ZodOptional<z.ZodString>;
+    availableVersions: z.ZodArray<z.ZodString, "many">;
+    repo: z.ZodString;
+    docsRoot: z.ZodOptional<z.ZodString>;
+    defaultDocs: z.ZodOptional<z.ZodString>;
+    docsUrl: z.ZodOptional<z.ZodString>;
+    githubUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    tagline: string;
+    frameworks: string[];
+    latestVersion: string;
+    availableVersions: string[];
+    repo: string;
+    description?: string | undefined;
+    latestBranch?: string | undefined;
+    docsRoot?: string | undefined;
+    defaultDocs?: string | undefined;
+    docsUrl?: string | undefined;
+    githubUrl?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    tagline: string;
+    frameworks: string[];
+    latestVersion: string;
+    availableVersions: string[];
+    repo: string;
+    description?: string | undefined;
+    latestBranch?: string | undefined;
+    docsRoot?: string | undefined;
+    defaultDocs?: string | undefined;
+    docsUrl?: string | undefined;
+    githubUrl?: string | undefined;
+}>;
+export declare const LibrariesResponseSchema: z.ZodObject<{
+    libraries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        tagline: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        frameworks: z.ZodArray<z.ZodString, "many">;
+        latestVersion: z.ZodString;
+        latestBranch: z.ZodOptional<z.ZodString>;
+        availableVersions: z.ZodArray<z.ZodString, "many">;
+        repo: z.ZodString;
+        docsRoot: z.ZodOptional<z.ZodString>;
+        defaultDocs: z.ZodOptional<z.ZodString>;
+        docsUrl: z.ZodOptional<z.ZodString>;
+        githubUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        tagline: string;
+        frameworks: string[];
+        latestVersion: string;
+        availableVersions: string[];
+        repo: string;
+        description?: string | undefined;
+        latestBranch?: string | undefined;
+        docsRoot?: string | undefined;
+        defaultDocs?: string | undefined;
+        docsUrl?: string | undefined;
+        githubUrl?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        tagline: string;
+        frameworks: string[];
+        latestVersion: string;
+        availableVersions: string[];
+        repo: string;
+        description?: string | undefined;
+        latestBranch?: string | undefined;
+        docsRoot?: string | undefined;
+        defaultDocs?: string | undefined;
+        docsUrl?: string | undefined;
+        githubUrl?: string | undefined;
+    }>, "many">;
+    groups: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    groupNames: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    libraries: {
+        id: string;
+        name: string;
+        tagline: string;
+        frameworks: string[];
+        latestVersion: string;
+        availableVersions: string[];
+        repo: string;
+        description?: string | undefined;
+        latestBranch?: string | undefined;
+        docsRoot?: string | undefined;
+        defaultDocs?: string | undefined;
+        docsUrl?: string | undefined;
+        githubUrl?: string | undefined;
+    }[];
+    groups: Record<string, string[]>;
+    groupNames: Record<string, string>;
+}, {
+    libraries: {
+        id: string;
+        name: string;
+        tagline: string;
+        frameworks: string[];
+        latestVersion: string;
+        availableVersions: string[];
+        repo: string;
+        description?: string | undefined;
+        latestBranch?: string | undefined;
+        docsRoot?: string | undefined;
+        defaultDocs?: string | undefined;
+        docsUrl?: string | undefined;
+        githubUrl?: string | undefined;
+    }[];
+    groups: Record<string, string[]>;
+    groupNames: Record<string, string>;
+}>;
+export declare const PartnerSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    tagline: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    category: z.ZodString;
+    categoryLabel: z.ZodString;
+    libraries: z.ZodArray<z.ZodString, "many">;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description: string;
+    libraries: string[];
+    category: string;
+    categoryLabel: string;
+    url: string;
+    tagline?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    description: string;
+    libraries: string[];
+    category: string;
+    categoryLabel: string;
+    url: string;
+    tagline?: string | undefined;
+}>;
+export declare const PartnersResponseSchema: z.ZodObject<{
+    partners: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        tagline: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        category: z.ZodString;
+        categoryLabel: z.ZodString;
+        libraries: z.ZodArray<z.ZodString, "many">;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description: string;
+        libraries: string[];
+        category: string;
+        categoryLabel: string;
+        url: string;
+        tagline?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        description: string;
+        libraries: string[];
+        category: string;
+        categoryLabel: string;
+        url: string;
+        tagline?: string | undefined;
+    }>, "many">;
+    categories: z.ZodArray<z.ZodString, "many">;
+    categoryLabels: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    partners: {
+        id: string;
+        name: string;
+        description: string;
+        libraries: string[];
+        category: string;
+        categoryLabel: string;
+        url: string;
+        tagline?: string | undefined;
+    }[];
+    categories: string[];
+    categoryLabels: Record<string, string>;
+}, {
+    partners: {
+        id: string;
+        name: string;
+        description: string;
+        libraries: string[];
+        category: string;
+        categoryLabel: string;
+        url: string;
+        tagline?: string | undefined;
+    }[];
+    categories: string[];
+    categoryLabels: Record<string, string>;
+}>;
+export type Library = z.infer<typeof LibrarySchema>;
+export type LibrariesResponse = z.infer<typeof LibrariesResponseSchema>;
+export type Partner = z.infer<typeof PartnerSchema>;
+export type PartnersResponse = z.infer<typeof PartnersResponseSchema>;

package/dist/types/mcp.d.ts

@@ -0,0 +1,6 @@
+export declare function runMCPServer(sse: boolean, { forcedAddOns, appName, name, }: {
+    forcedMode?: string;
+    forcedAddOns?: Array<string>;
+    appName?: string;
+    name?: string;
+}): Promise<void>;

package/dist/types/options.d.ts

@@ -0,0 +1,8 @@
+import type { Options } from '@tanstack/create';
+import type { CliOptions } from './types.js';
+export declare function promptForCreateOptions(cliOptions: CliOptions, { forcedAddOns, forcedMode, showDeploymentOptions, }: {
+    forcedAddOns?: Array<string>;
+    forcedMode?: string;
+    showDeploymentOptions?: boolean;
+}): Promise<Required<Options> | undefined>;
+export declare function promptForAddOns(): Promise<Array<string>>;

package/dist/types/types.d.ts

@@ -0,0 +1,25 @@
+import type { PackageManager } from '@tanstack/create';
+export type TemplateOptions = 'typescript' | 'javascript' | 'file-router';
+export interface CliOptions {
+    template?: TemplateOptions;
+    framework?: string;
+    tailwind?: boolean;
+    packageManager?: PackageManager;
+    toolchain?: string | false;
+    deployment?: string;
+    projectName?: string;
+    git?: boolean;
+    addOns?: Array<string> | boolean;
+    listAddOns?: boolean;
+    addonDetails?: string;
+    mcp?: boolean;
+    mcpSse?: boolean;
+    starter?: string;
+    targetDir?: string;
+    interactive?: boolean;
+    ui?: boolean;
+    devWatch?: string;
+    install?: boolean;
+    addOnConfig?: string;
+    force?: boolean;
+}

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

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

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

@@ -0,0 +1,12 @@
+import type { PackageManager } from '@tanstack/create';
+import type { Framework } from '@tanstack/create/dist/types/types.js';
+export declare function getProjectName(): Promise<string>;
+export declare function selectRouterType(): Promise<string>;
+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: string, type: string, message: string, forcedAddOns?: Array<string>, allowMultiple?: boolean): Promise<Array<string>>;
+export declare function selectGit(): Promise<boolean>;
+export declare function selectToolchain(framework: Framework, toolchain?: string | false): Promise<string | undefined>;
+export declare function promptForAddOnOptions(addOnIds: Array<string>, framework: Framework): Promise<Record<string, Record<string, any>>>;
+export declare function selectDeployment(framework: Framework, deployment?: string): Promise<string | undefined>;

package/dist/types/utils.d.ts

@@ -0,0 +1,8 @@
+import type { TemplateOptions } from './types.js';
+export declare function convertTemplateToMode(template: TemplateOptions): string;
+export declare function sanitizePackageName(name: string): string;
+export declare function getCurrentDirectoryName(): string;
+export declare function validateProjectName(name: string): {
+    valid: boolean;
+    error: string;
+};

package/dist/types.js

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

package/dist/ui-environment.js

@@ -0,0 +1,52 @@
+import { cancel, confirm, intro, isCancel, log, outro, spinner, } from '@clack/prompts';
+import chalk from 'chalk';
+import { createDefaultEnvironment } from '@tanstack/create';
+export function createUIEnvironment(appName, silent) {
+    const defaultEnvironment = createDefaultEnvironment();
+    let newEnvironment = {
+        ...defaultEnvironment,
+        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;
+}

package/dist/ui-prompts.js

@@ -0,0 +1,244 @@
+import { cancel, confirm, isCancel, multiselect, note, select, text, } from '@clack/prompts';
+import { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getAllAddOns, } from '@tanstack/create';
+import { validateProjectName } from './utils.js';
+export async function getProjectName() {
+    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';
+            }
+            const { valid, error } = validateProjectName(value);
+            if (!valid) {
+                return error;
+            }
+        },
+    });
+    if (isCancel(value)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return value;
+}
+export async function selectRouterType() {
+    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);
+    }
+    return routerType;
+}
+export async function selectTypescript() {
+    const typescriptEnable = await confirm({
+        message: 'Would you like to use TypeScript?',
+        initialValue: true,
+    });
+    if (isCancel(typescriptEnable)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return typescriptEnable;
+}
+export async function selectTailwind() {
+    const tailwind = await confirm({
+        message: 'Would you like to use Tailwind CSS?',
+        initialValue: true,
+    });
+    if (isCancel(tailwind)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return tailwind;
+}
+export async function selectPackageManager() {
+    const packageManager = await select({
+        message: 'Select package manager:',
+        options: SUPPORTED_PACKAGE_MANAGERS.map((pm) => ({
+            value: pm,
+            label: pm,
+        })),
+        initialValue: DEFAULT_PACKAGE_MANAGER,
+    });
+    if (isCancel(packageManager)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return packageManager;
+}
+// Track if we've shown the multiselect help text
+let hasShownMultiselectHelp = false;
+export async function selectAddOns(framework, mode, type, message, forcedAddOns = [], allowMultiple = true) {
+    const allAddOns = await getAllAddOns(framework, mode);
+    const addOns = allAddOns.filter((addOn) => addOn.type === type);
+    if (addOns.length === 0) {
+        return [];
+    }
+    // Show help text only once
+    if (!hasShownMultiselectHelp) {
+        note('Use ↑/↓ to navigate • Space to select/deselect • Enter to confirm', 'Keyboard Shortcuts');
+        hasShownMultiselectHelp = true;
+    }
+    if (allowMultiple) {
+        const value = await multiselect({
+            message,
+            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);
+        }
+        return value;
+    }
+    else {
+        const value = await select({
+            message,
+            options: [
+                {
+                    value: 'none',
+                    label: 'None',
+                },
+                ...addOns
+                    .filter((addOn) => !forcedAddOns.includes(addOn.id))
+                    .map((addOn) => ({
+                    value: addOn.id,
+                    label: addOn.name,
+                    hint: addOn.description,
+                })),
+            ],
+            initialValue: 'none',
+        });
+        if (isCancel(value)) {
+            cancel('Operation cancelled.');
+            process.exit(0);
+        }
+        return value === 'none' ? [] : [value];
+    }
+}
+export async function selectGit() {
+    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);
+    }
+    return git;
+}
+export async function selectToolchain(framework, toolchain) {
+    if (toolchain === false) {
+        return undefined;
+    }
+    const toolchains = new Set();
+    for (const addOn of framework.getAddOns()) {
+        if (addOn.type === 'toolchain') {
+            toolchains.add(addOn);
+            if (toolchain && addOn.id === toolchain) {
+                return toolchain;
+            }
+        }
+    }
+    const tc = await select({
+        message: 'Select toolchain',
+        options: [
+            {
+                value: undefined,
+                label: 'None',
+            },
+            ...Array.from(toolchains).map((tc) => ({
+                value: tc.id,
+                label: tc.name,
+            })),
+        ],
+        initialValue: undefined,
+    });
+    if (isCancel(tc)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return tc;
+}
+export async function promptForAddOnOptions(addOnIds, framework) {
+    const addOnOptions = {};
+    for (const addOnId of addOnIds) {
+        const addOn = framework.getAddOns().find((a) => a.id === addOnId);
+        if (!addOn || !addOn.options)
+            continue;
+        addOnOptions[addOnId] = {};
+        for (const [optionName, option] of Object.entries(addOn.options)) {
+            if (option && typeof option === 'object' && 'type' in option) {
+                if (option.type === 'select') {
+                    const selectOption = option;
+                    const value = await select({
+                        message: `${addOn.name}: ${selectOption.label}`,
+                        options: selectOption.options.map((opt) => ({
+                            value: opt.value,
+                            label: opt.label,
+                        })),
+                        initialValue: selectOption.default,
+                    });
+                    if (isCancel(value)) {
+                        cancel('Operation cancelled.');
+                        process.exit(0);
+                    }
+                    addOnOptions[addOnId][optionName] = value;
+                }
+                // Future option types can be added here
+            }
+        }
+    }
+    return addOnOptions;
+}
+export async function selectDeployment(framework, deployment) {
+    const deployments = new Set();
+    let initialValue = undefined;
+    for (const addOn of framework
+        .getAddOns()
+        .sort((a, b) => a.name.localeCompare(b.name))) {
+        if (addOn.type === 'deployment') {
+            deployments.add(addOn);
+            if (deployment && addOn.id === deployment) {
+                return deployment;
+            }
+            if (addOn.default) {
+                initialValue = addOn.id;
+            }
+        }
+    }
+    const dp = await select({
+        message: 'Select deployment adapter',
+        options: [
+            ...Array.from(deployments).map((d) => ({
+                value: d.id,
+                label: d.name,
+            })),
+        ],
+        initialValue: initialValue,
+    });
+    if (isCancel(dp)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return dp;
+}

package/dist/utils.js

@@ -0,0 +1,30 @@
+import { basename } from 'node:path';
+import validatePackageName from 'validate-npm-package-name';
+export function convertTemplateToMode(template) {
+    if (template === 'typescript' || template === 'javascript') {
+        return 'code-router';
+    }
+    return 'file-router';
+}
+export function sanitizePackageName(name) {
+    return name
+        .toLowerCase()
+        .replace(/\s+/g, '-') // Replace spaces with hyphens
+        .replace(/_/g, '-') // Replace underscores with hyphens
+        .replace(/[^a-z0-9-]/g, '') // Remove invalid characters
+        .replace(/^[^a-z]+/, '') // Ensure it starts with a letter
+        .replace(/-+/g, '-') // Collapse multiple hyphens
+        .replace(/-$/, ''); // Remove trailing hyphen
+}
+export function getCurrentDirectoryName() {
+    return basename(process.cwd());
+}
+export function validateProjectName(name) {
+    const { validForNewPackages, validForOldPackages, errors, warnings } = validatePackageName(name);
+    const error = errors?.[0] || warnings?.[0];
+    return {
+        valid: validForNewPackages && validForOldPackages,
+        error: error?.replace(/name/g, 'Project name') ||
+            'Project name does not meet npm package naming requirements',
+    };
+}