@tanstack/cli 0.60.1 → 0.62.0

package/src/mcp.ts

@@ -1,263 +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,
-  createDefaultEnvironment,
-  finalizeAddOns,
-  getFrameworkByName,
-  getFrameworks,
-  populateAddOnOptionsDefaults,
-} from '@tanstack/create'
-
-import { registerDocTools } from './mcp/tools.js'
-
-function createServer({
-  appName,
-  forcedAddOns = [],
-}: {
-  appName?: string
-  forcedAddOns?: Array<string>
-  name?: string
-}) {
-  const server = new McpServer({
-    name: `${appName} Application Builder`,
-    version: '1.0.0',
-  })
-
-  const frameworks = getFrameworks()
-  const frameworkNames = frameworks.map((framework) => framework.name)
-
-  server.tool(
-    'listTanStackAddOns',
-    'List the available add-ons for creating TanStack applications',
-    {
-      framework: z
-        .string()
-        .describe(
-          `The framework to use. Available frameworks: ${frameworkNames.join(', ')}`,
-        ),
-    },
-    ({ framework: frameworkName }) => {
-      const framework = getFrameworkByName(frameworkName)!
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(
-              framework
-                .getAddOns()
-                .filter((addOn) => addOn.modes.includes('file-router'))
-                .map((addOn) => ({
-                  id: addOn.id,
-                  name: addOn.name,
-                  description: addOn.description,
-                  type: addOn.type,
-                  category: addOn.category,
-                  link: addOn.link,
-                  warning: addOn.warning,
-                  exclusive: addOn.exclusive,
-                  options: addOn.options,
-                  dependsOn: addOn.dependsOn,
-                })),
-            ),
-          },
-        ],
-      }
-    },
-  )
-
-  server.tool(
-    'getAddOnDetails',
-    'Get detailed information about a specific add-on including implementation patterns, routes, dependencies, and documentation',
-    {
-      framework: z
-        .string()
-        .describe(
-          `The framework to use. Available frameworks: ${frameworkNames.join(', ')}`,
-        ),
-      addOnId: z
-        .string()
-        .describe('The ID of the add-on to get details for'),
-    },
-    async ({ framework: frameworkName, addOnId }) => {
-      const framework = getFrameworkByName(frameworkName)!
-      const allAddOns = framework.getAddOns()
-      const addOn =
-        allAddOns.find((a) => a.id === addOnId) ??
-        allAddOns.find(
-          (a) => a.id.toLowerCase() === addOnId.toLowerCase(),
-        )
-
-      if (!addOn) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({ error: `Add-on '${addOnId}' not found` }),
-            },
-          ],
-        }
-      }
-
-      // Get file list for context
-      const files = await addOn.getFiles()
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({
-              id: addOn.id,
-              name: addOn.name,
-              description: addOn.description,
-              type: addOn.type,
-              category: addOn.category,
-              phase: addOn.phase,
-              modes: addOn.modes,
-              link: addOn.link,
-              warning: addOn.warning,
-              exclusive: addOn.exclusive,
-              dependsOn: addOn.dependsOn,
-              options: addOn.options,
-              routes: addOn.routes,
-              packageAdditions: addOn.packageAdditions,
-              shadcnComponents: addOn.shadcnComponents,
-              integrations: addOn.integrations,
-              readme: addOn.readme,
-              files,
-              author: addOn.author,
-              version: addOn.version,
-              license: addOn.license,
-            }),
-          },
-        ],
-      }
-    },
-  )
-
-  server.tool(
-    'createTanStackApplication',
-    'Create a new TanStack application',
-    {
-      framework: z
-        .string()
-        .describe(
-          `The framework to use. Available frameworks: ${frameworkNames.join(', ')}`,
-        ),
-      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.string()).describe('Array of add-on IDs to install. Use listTanStackAddOns tool to see available add-ons and their configuration options. Example: ["prisma", "shadcn", "tanstack-query"]'),
-      addOnOptions: z.record(z.record(z.any())).optional().describe('Configuration options for add-ons. Format: {"addOnId": {"optionName": "value"}}. Use listTanStackAddOns to see available options for each add-on.'),
-      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 ({
-      framework: frameworkName,
-      projectName,
-      addOns,
-      addOnOptions,
-      cwd,
-      targetDir,
-    }) => {
-      const framework = getFrameworkByName(frameworkName)!
-      try {
-        process.chdir(cwd)
-        try {
-          const chosenAddOns = await finalizeAddOns(
-            framework,
-            'file-router',
-            Array.from(
-              new Set([
-                ...(addOns as unknown as Array<string>),
-                ...forcedAddOns,
-              ]),
-            ),
-          )
-          await createApp(createDefaultEnvironment(), {
-            projectName: projectName.replace(/^\//, './'),
-            targetDir,
-            framework,
-            typescript: true,
-            tailwind: true,
-            packageManager: 'pnpm',
-            mode: 'file-router',
-            chosenAddOns,
-            addOnOptions: addOnOptions || populateAddOnOptionsDefaults(chosenAddOns),
-            git: true,
-          })
-        } catch (error) {
-          console.error(error)
-          return {
-            content: [
-              { type: 'text', text: `Error creating application: ${error}` },
-            ],
-          }
-        }
-        return {
-          content: [{ type: 'text', text: 'Application created successfully' }],
-        }
-      } catch (error) {
-        return {
-          content: [
-            { type: 'text', text: `Error creating application: ${error}` },
-          ],
-        }
-      }
-    },
-  )
-
-  // Register doc/ecosystem tools from TanStack API
-  registerDocTools(server)
-
-  return server
-}
-
-export async function runMCPServer(
-  sse: boolean,
-  {
-    forcedAddOns,
-    appName,
-    name,
-  }: {
-    forcedAddOns?: Array<string>
-    appName?: string
-    name?: string
-  },
-) {
-  let transport: SSEServerTransport | null = 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/src/options.ts

@@ -1,234 +0,0 @@
-import { intro } from '@clack/prompts'
-
-import {
-  finalizeAddOns,
-  getFrameworkById,
-  getPackageManager,
-  populateAddOnOptionsDefaults,
-  readConfigFile,
-} from '@tanstack/create'
-
-import {
-  getProjectName,
-  promptForAddOnOptions,
-  promptForEnvVars,
-  selectAddOns,
-  selectDeployment,
-  selectExamples,
-  selectGit,
-  selectPackageManager,
-  selectToolchain,
-} from './ui-prompts.js'
-
-import {
-  getCurrentDirectoryName,
-  sanitizePackageName,
-  validateProjectName,
-} from './utils.js'
-import type { Options } from '@tanstack/create'
-
-import type { CliOptions } from './types.js'
-
-export async function promptForCreateOptions(
-  cliOptions: CliOptions,
-  {
-    forcedAddOns = [],
-    showDeploymentOptions = false,
-  }: {
-    forcedAddOns?: Array<string>
-    showDeploymentOptions?: boolean
-  },
-): Promise<Required<Options> | undefined> {
-  const options = {} as Required<Options>
-
-  options.framework = getFrameworkById(cliOptions.framework || 'react')!
-
-  // Validate project name
-  if (cliOptions.projectName) {
-    // Handle "." as project name - use sanitized current directory name
-    if (cliOptions.projectName === '.') {
-      options.projectName = sanitizePackageName(getCurrentDirectoryName())
-    } else {
-      options.projectName = cliOptions.projectName
-    }
-    const { valid, error } = validateProjectName(options.projectName)
-    if (!valid) {
-      console.error(error)
-      process.exit(1)
-    }
-  } else {
-    options.projectName = await getProjectName()
-  }
-
-  // Mode is always file-router (TanStack Start)
-  options.mode = 'file-router'
-  const template = cliOptions.template?.toLowerCase().trim()
-  const isLegacyTemplate =
-    template &&
-    ['file-router', 'typescript', 'tsx', 'javascript', 'js', 'jsx'].includes(
-      template,
-    )
-  const routerOnly =
-    !!cliOptions.routerOnly ||
-    (isLegacyTemplate ? template !== 'file-router' : false)
-
-  // TypeScript is always enabled with file-router
-  options.typescript = true
-
-  // Package manager selection
-  if (cliOptions.packageManager) {
-    options.packageManager = cliOptions.packageManager
-  } else {
-    const detectedPackageManager = await getPackageManager()
-    options.packageManager =
-      detectedPackageManager || (await selectPackageManager())
-  }
-
-  // Toolchain selection
-  const toolchain = await selectToolchain(
-    options.framework,
-    cliOptions.toolchain,
-  )
-
-  // Deployment selection
-  const deployment = showDeploymentOptions
-    ? routerOnly
-      ? undefined
-      : await selectDeployment(options.framework, cliOptions.deployment)
-    : undefined
-
-  // Add-ons selection
-  const addOns: Set<string> = new Set()
-
-  // Examples/demo pages are enabled by default
-  const includeExamples =
-    cliOptions.examples ?? (routerOnly ? false : await selectExamples())
-  ;(options as Required<Options> & { includeExamples?: boolean }).includeExamples =
-    includeExamples
-
-  if (toolchain) {
-    addOns.add(toolchain)
-  }
-  if (deployment) {
-    addOns.add(deployment)
-  }
-
-  if (!routerOnly) {
-    for (const addOn of forcedAddOns) {
-      addOns.add(addOn)
-    }
-  }
-
-  if (!routerOnly && Array.isArray(cliOptions.addOns)) {
-    for (const addOn of cliOptions.addOns) {
-      if (addOn.toLowerCase() === 'start') {
-        continue
-      }
-      addOns.add(addOn)
-    }
-  } else if (!routerOnly) {
-    for (const addOn of await selectAddOns(
-      options.framework,
-      options.mode,
-      'add-on',
-      'What add-ons would you like for your project?',
-      forcedAddOns,
-    )) {
-      addOns.add(addOn)
-    }
-
-    if (includeExamples) {
-      for (const addOn of await selectAddOns(
-        options.framework,
-        options.mode,
-        'example',
-        'Would you like an example?',
-        forcedAddOns,
-        false,
-      )) {
-        addOns.add(addOn)
-      }
-    }
-  }
-
-  const chosenAddOns = Array.from(
-    await finalizeAddOns(options.framework, options.mode, Array.from(addOns)),
-  )
-  options.chosenAddOns = includeExamples
-    ? chosenAddOns
-    : chosenAddOns.filter((addOn) => addOn.type !== 'example')
-
-  // Tailwind is always enabled
-  options.tailwind = true
-
-  // Prompt for add-on options in interactive mode
-  if (Array.isArray(cliOptions.addOns)) {
-    // Non-interactive mode: use defaults
-    options.addOnOptions = populateAddOnOptionsDefaults(options.chosenAddOns)
-  } else {
-    // Interactive mode: prompt for options
-    const userOptions = await promptForAddOnOptions(
-      options.chosenAddOns.map((a) => a.id),
-      options.framework,
-    )
-    const defaultOptions = populateAddOnOptionsDefaults(options.chosenAddOns)
-    // Merge user options with defaults
-    options.addOnOptions = { ...defaultOptions, ...userOptions }
-  }
-
-  // Prompt for env vars exposed by selected add-ons in interactive mode
-  const envVarValues = Array.isArray(cliOptions.addOns)
-    ? {}
-    : await promptForEnvVars(options.chosenAddOns)
-  ;(options as Required<Options> & { envVarValues?: Record<string, string> }).envVarValues =
-    envVarValues
-
-  options.git = cliOptions.git ?? (await selectGit())
-  if (cliOptions.install === false) {
-    options.install = false
-  }
-
-  return options
-}
-
-export async function promptForAddOns(): Promise<Array<string>> {
-  const config = await readConfigFile(process.cwd())
-
-  if (!config) {
-    console.error('No config file found')
-    process.exit(1)
-  }
-
-  const framework = getFrameworkById(config.framework)
-
-  if (!framework) {
-    console.error(`Unknown framework: ${config.framework}`)
-    process.exit(1)
-  }
-
-  intro(`Adding new add-ons to '${config.projectName}'`)
-
-  const addOns: Set<string> = new Set()
-
-  for (const addOn of await selectAddOns(
-    framework,
-    config.mode!,
-    'add-on',
-    'What add-ons would you like for your project?',
-    config.chosenAddOns,
-  )) {
-    addOns.add(addOn)
-  }
-
-  for (const addOn of await selectAddOns(
-    framework,
-    config.mode!,
-    'example',
-    'Would you like any examples?',
-    config.chosenAddOns,
-  )) {
-    addOns.add(addOn)
-  }
-
-  return Array.from(addOns)
-}

package/src/types.ts

@@ -1,28 +0,0 @@
-import type { PackageManager } from '@tanstack/create'
-
-export interface CliOptions {
-  framework?: string
-  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
-  templateId?: string
-  targetDir?: string
-  interactive?: boolean
-  devWatch?: string
-  runDev?: boolean
-  install?: boolean
-  addOnConfig?: string
-  force?: boolean
-  routerOnly?: boolean
-  template?: string
-  tailwind?: boolean
-  examples?: boolean
-}

package/src/ui-environment.ts

@@ -1,74 +0,0 @@
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  log,
-  outro,
-  spinner,
-} from '@clack/prompts'
-import chalk from 'chalk'
-
-import { createDefaultEnvironment } from '@tanstack/create'
-
-import type { Environment } from '@tanstack/create'
-
-export function createUIEnvironment(
-  appName: string,
-  silent: boolean,
-): Environment {
-  const defaultEnvironment = createDefaultEnvironment()
-
-  let newEnvironment = {
-    ...defaultEnvironment,
-    appName,
-  }
-
-  if (!silent) {
-    newEnvironment = {
-      ...newEnvironment,
-      intro: (message: string) => {
-        intro(message)
-      },
-      outro: (message: string) => {
-        outro(message)
-      },
-      info: (title?: string, message?: string) => {
-        log.info(
-          `${title ? chalk.red(title) : ''}${message ? '\n' + chalk.green(message) : ''}`,
-        )
-      },
-      error: (title?: string, message?: string) => {
-        log.error(
-          `${title ? `${title}: ` : ''}${message ? '\n' + message : ''}`,
-        )
-      },
-      warn: (title?: string, message?: string) => {
-        log.warn(`${title ? `${title}: ` : ''}${message ? '\n' + message : ''}`)
-      },
-      confirm: async (message: string) => {
-        const shouldContinue = await confirm({
-          message,
-        })
-        if (isCancel(shouldContinue)) {
-          cancel('Operation cancelled.')
-          process.exit(0)
-        }
-        return shouldContinue
-      },
-      spinner: () => {
-        const s = spinner()
-        return {
-          start: (message: string) => {
-            s.start(message)
-          },
-          stop: (message: string) => {
-            s.stop(message)
-          },
-        }
-      },
-    }
-  }
-
-  return newEnvironment
-}