@tanstack/cta-engine 0.14.3 → 0.14.4

package/dist/mcp.js

@@ -1,229 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import express from 'express';
-import { z } from 'zod';
-import { createApp } from './create-app.js';
-import { finalizeAddOns } from './add-ons.js';
-import { createDefaultEnvironment } from './environment.js';
-const tanStackReactAddOns = [
-    {
-        id: 'clerk',
-        description: 'Enable authentication with Clerk',
-    },
-    {
-        id: 'convex',
-        description: 'Enable a database using Convex',
-    },
-    {
-        id: 'form',
-        description: 'Form handling library',
-    },
-    {
-        id: 'netlify',
-        description: 'Enable deployments to Netlify',
-    },
-    {
-        id: 'sentry',
-        description: 'Enable Sentry error tracking',
-    },
-    {
-        id: 'shadcn',
-        description: 'Enable integration of the Shadcn UI component library',
-    },
-    {
-        id: 'start',
-        description: 'Set this if you want a TanStack Start application that supports server functions or APIs',
-    },
-    {
-        id: 'tanstack-query',
-        description: 'Enable TanStack Query for data fetching',
-    },
-    {
-        id: 'store',
-        description: 'Enable the TanStack Store state management library',
-    },
-    {
-        id: 'tanchat',
-        description: 'Add an AI chatbot example to the application',
-    },
-];
-const tanStackSolidAddOns = [
-    {
-        id: 'solid-ui',
-        description: 'Enable integration of the Solid UI component library',
-    },
-    {
-        id: 'form',
-        description: 'Form handling library',
-    },
-    {
-        id: 'sentry',
-        description: 'Enable Sentry error tracking',
-    },
-    {
-        id: 'store',
-        description: 'Enable the TanStack Store state management library',
-    },
-    {
-        id: 'start',
-        description: 'Set this if you want a TanStack Start application that supports server functions or APIs',
-    },
-    {
-        id: 'tanstack-query',
-        description: 'Enable TanStack Query for data fetching',
-    },
-    {
-        id: 'tanchat',
-        description: 'Add an AI chatbot example to the application',
-    },
-];
-function createServer({ appName, forcedAddOns = [], name, }) {
-    const server = new McpServer({
-        name: `${appName} Application Builder`,
-        version: '1.0.0',
-    });
-    server.tool('listTanStackReactAddOns', {}, () => {
-        return {
-            content: [{ type: 'text', text: JSON.stringify(tanStackReactAddOns) }],
-        };
-    });
-    server.tool('createTanStackReactApplication', {
-        projectName: z
-            .string()
-            .describe('The package.json module name of the application (will also be the directory name)'),
-        cwd: z.string().describe('The directory to create the application in'),
-        addOns: z
-            .array(z.enum([
-            'clerk',
-            'convex',
-            'form',
-            'netlify',
-            'sentry',
-            'shadcn',
-            'start',
-            'store',
-            'tanstack-query',
-            'tanchat',
-        ]))
-            .describe('The IDs of the add-ons to install'),
-        targetDir: z
-            .string()
-            .describe('The directory to create the application in. Use the absolute path of the directory you want the application to be created in'),
-    }, async ({ projectName, addOns, cwd, targetDir }) => {
-        try {
-            process.chdir(cwd);
-            const chosenAddOns = await finalizeAddOns('react', 'file-router', Array.from(new Set([...addOns, ...forcedAddOns])));
-            await createApp({
-                projectName: projectName.replace(/^\//, './'),
-                framework: 'react',
-                typescript: true,
-                tailwind: true,
-                packageManager: 'pnpm',
-                toolchain: 'none',
-                mode: 'file-router',
-                addOns: true,
-                chosenAddOns,
-                git: true,
-                variableValues: {},
-            }, {
-                silent: true,
-                environment: createDefaultEnvironment(),
-                name,
-                cwd: targetDir,
-            });
-            return {
-                content: [{ type: 'text', text: 'Application created successfully' }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: `Error creating application: ${error}` },
-                ],
-            };
-        }
-    });
-    server.tool('listTanStackSolidAddOns', {}, () => {
-        return {
-            content: [{ type: 'text', text: JSON.stringify(tanStackSolidAddOns) }],
-        };
-    });
-    server.tool('createTanStackSolidApplication', {
-        projectName: z
-            .string()
-            .describe('The package.json module name of the application (will also be the directory name)'),
-        cwd: z.string().describe('The directory to create the application in'),
-        addOns: z
-            .array(z.enum([
-            'solid-ui',
-            'form',
-            'sentry',
-            'store',
-            'tanstack-query',
-            'tanchat',
-        ]))
-            .describe('The IDs of the add-ons to install'),
-        targetDir: z
-            .string()
-            .describe('The directory to create the application in. Use the absolute path of the directory you want the application to be created in'),
-    }, async ({ projectName, addOns, cwd, targetDir }) => {
-        try {
-            process.chdir(cwd);
-            const chosenAddOns = await finalizeAddOns('solid', 'file-router', Array.from(new Set([...addOns, ...forcedAddOns])));
-            await createApp({
-                projectName: projectName.replace(/^\//, './'),
-                framework: 'solid',
-                typescript: true,
-                tailwind: true,
-                packageManager: 'pnpm',
-                toolchain: 'none',
-                mode: 'file-router',
-                addOns: true,
-                chosenAddOns,
-                git: true,
-                variableValues: {},
-            }, {
-                silent: true,
-                environment: createDefaultEnvironment(),
-                name,
-                cwd: targetDir,
-            });
-            return {
-                content: [{ type: 'text', text: 'Application created successfully' }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: `Error creating application: ${error}` },
-                ],
-            };
-        }
-    });
-    return server;
-}
-export default async function runServer(sse, { forcedAddOns, appName, name, }) {
-    let transport = null;
-    const server = createServer({ appName, forcedAddOns, name });
-    if (sse) {
-        const app = express();
-        app.get('/sse', (req, res) => {
-            transport = new SSEServerTransport('/messages', res);
-            server.connect(transport);
-        });
-        app.post('/messages', (req, res) => {
-            if (transport) {
-                transport.handlePostMessage(req, res);
-            }
-        });
-        const port = process.env.PORT || 8080;
-        app.listen(port, () => {
-            console.log(`Server is running on port http://localhost:${port}/sse`);
-        });
-    }
-    else {
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-    }
-}

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,7 +0,0 @@
-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/custom-add-on.d.ts

@@ -1,3 +0,0 @@
-type AddOnMode = 'add-on' | 'overlay';
-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/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/add.ts

@@ -1,186 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { existsSync, statSync } from 'node:fs'
-import { basename, dirname, resolve } from 'node:path'
-import chalk from 'chalk'
-import { execa, execaSync } from 'execa'
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  log,
-  outro,
-  spinner,
-} from '@clack/prompts'
-
-import { CONFIG_FILE } from './constants.js'
-import {
-  createDefaultEnvironment,
-  createMemoryEnvironment,
-} from './environment.js'
-import { createApp } from './create-app.js'
-import { finalizeAddOns } from './add-ons.js'
-import { sortObject } from './utils.js'
-import { readConfigFile, writeConfigFile } from './config-file.js'
-
-import type { PersistedOptions } from './config-file.js'
-
-import type { Framework, Options } from './types.js'
-
-function isDirectory(path: string) {
-  return statSync(path).isDirectory()
-}
-
-async function hasPendingGitChanges() {
-  const status = await execaSync('git', ['status', '--porcelain'])
-  return status.stdout.length > 0
-}
-
-async function createOptions(
-  json: PersistedOptions,
-  addOns: Array<string>,
-): Promise<Required<Options>> {
-  return {
-    ...json,
-    tailwind: true,
-    chosenAddOns: await finalizeAddOns(
-      json.framework as Framework,
-      json.mode as string,
-      [...json.existingAddOns, ...addOns],
-    ),
-  } as Required<Options>
-}
-
-async function runCreateApp(options: Required<Options>) {
-  const { environment, output } = createMemoryEnvironment()
-  await createApp(options, {
-    silent: true,
-    environment,
-    cwd: process.cwd(),
-    name: 'create-tsrouter-app',
-  })
-  return output
-}
-
-export async function add(
-  addOns: Array<string>,
-  {
-    silent = false,
-  }: {
-    silent?: boolean
-  } = {},
-) {
-  const persistedOptions = await readConfigFile(process.cwd())
-  if (!persistedOptions) {
-    console.error(`${chalk.red('There is no .cta.json file in your project.')}
-
-This is probably because this was created with an older version of create-tsrouter-app.`)
-    return
-  }
-
-  if (!silent) {
-    intro(`Adding ${addOns.join(', ')} to the project...`)
-  }
-
-  if (await hasPendingGitChanges()) {
-    log.error(
-      `${chalk.red('You have pending git changes.')} Please commit or stash them before adding add-ons.`,
-    )
-    return
-  }
-
-  const newOptions = await createOptions(persistedOptions, addOns)
-
-  const output = await runCreateApp(newOptions)
-
-  const overwrittenFiles: Array<string> = []
-  const changedFiles: Array<string> = []
-  const contentMap = new Map<string, string>()
-  for (const file of Object.keys(output.files)) {
-    const relativeFile = file.replace(process.cwd(), '')
-    if (existsSync(file)) {
-      if (!isDirectory(file)) {
-        const contents = (await readFile(file)).toString()
-        if (
-          ['package.json', CONFIG_FILE].includes(basename(file)) ||
-          contents !== output.files[file]
-        ) {
-          overwrittenFiles.push(relativeFile)
-          contentMap.set(relativeFile, output.files[file])
-        }
-      }
-    } else {
-      changedFiles.push(relativeFile)
-      contentMap.set(relativeFile, output.files[file])
-    }
-  }
-
-  if (overwrittenFiles.length > 0 && !silent) {
-    log.warn(
-      `${chalk.yellow('The following will be overwritten:')}\n${overwrittenFiles.join('\n')}`,
-    )
-    const shouldContinue = await confirm({
-      message: 'Do you want to continue?',
-    })
-    if (isCancel(shouldContinue)) {
-      cancel('Operation cancelled.')
-      process.exit(0)
-    }
-  }
-
-  for (const file of [...changedFiles, ...overwrittenFiles]) {
-    const targetFile = `.${file}`
-    const fName = basename(file)
-    const contents = contentMap.get(file)!
-    if (fName === 'package.json') {
-      const currentJson = JSON.parse(
-        (await readFile(resolve(fName), 'utf-8')).toString(),
-      )
-      const newJson = JSON.parse(contents)
-
-      currentJson.scripts = newJson.scripts
-      currentJson.dependencies = sortObject({
-        ...currentJson.dependencies,
-        ...newJson.dependencies,
-      })
-      currentJson.devDependencies = sortObject({
-        ...currentJson.devDependencies,
-        ...newJson.devDependencies,
-      })
-
-      await writeFile(targetFile, JSON.stringify(currentJson, null, 2))
-    } else if (fName !== CONFIG_FILE) {
-      await mkdir(resolve(dirname(targetFile)), { recursive: true })
-      await writeFile(resolve(targetFile), contents)
-    }
-  }
-
-  // Handle commands
-  const originalOutput = await runCreateApp(
-    await createOptions(persistedOptions, []),
-  )
-  const originalCommands = new Set(
-    originalOutput.commands.map((c) => [c.command, ...c.args].join(' ')),
-  )
-  for (const command of output.commands) {
-    const commandString = [command.command, ...command.args].join(' ')
-    if (!originalCommands.has(commandString)) {
-      await execa(command.command, command.args)
-    }
-  }
-  const realEnvironment = createDefaultEnvironment()
-  writeConfigFile(realEnvironment, process.cwd(), newOptions)
-
-  const s = silent ? null : spinner()
-  s?.start(`Installing dependencies via ${newOptions.packageManager}...`)
-  await realEnvironment.execute(
-    newOptions.packageManager,
-    ['install'],
-    resolve(process.cwd()),
-  )
-  s?.stop(`Installed dependencies`)
-
-  if (!silent) {
-    outro('Add-ons added successfully!')
-  }
-}

package/src/cli.ts

@@ -1,210 +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,
-  Mode,
-  Options,
-  TemplateOptions,
-} from './types.js'
-
-export function cli({
-  name,
-  appName,
-  forcedMode,
-  forcedAddOns,
-}: {
-  name: string
-  appName: string
-  forcedMode?: Mode
-  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-overlay')
-  //   .description('Create or update a project overlay from the current project')
-  //   .action(async () => {
-  //     await initAddOn('overlay')
-  //   })
-
-  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('--overlay [url]', 'add an overlay from a 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('--interactive', 'interactive mode', false)
-    .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: forcedMode as TemplateOptions,
-        forcedAddOns,
-      })
-    } else if (options.mcp || options.mcpSse) {
-      await runServer(!!options.mcpSse, {
-        forcedMode: forcedMode as TemplateOptions,
-        forcedAddOns,
-        appName,
-      })
-    } else {
-      try {
-        const cliOptions = {
-          projectName,
-          ...options,
-        } as CliOptions
-
-        if (forcedMode) {
-          cliOptions.template = forcedMode as TemplateOptions
-        }
-
-        let finalOptions: Options | undefined
-        if (cliOptions.interactive) {
-          cliOptions.addOns = true
-        } else {
-          finalOptions = await normalizeOptions(
-            cliOptions,
-            forcedMode,
-            forcedAddOns,
-          )
-        }
-
-        if (finalOptions) {
-          intro(`Creating a new ${appName} app in ${projectName}...`)
-        } else {
-          intro(`Let's configure your ${appName} application`)
-          finalOptions = await promptForOptions(cliOptions, {
-            forcedMode: forcedMode as TemplateOptions,
-            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()
-}