@tanstack/cli 0.0.7 → 0.48.2

package/src/commands/mcp.ts

@@ -1,203 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js'
-import express from 'express'
-import { z } from 'zod'
-import { fetchIntegrations, fetchManifest } from '../api/fetch.js'
-import { compile } from '../engine/compile.js'
-import { registerDocTools } from '../mcp/tools.js'
-import type { RouterMode } from '../engine/types.js'
-
-interface McpOptions {
-  sse?: boolean
-  port?: string
-}
-
-function createServer() {
-  const server = new McpServer({
-    name: 'TanStack CLI',
-    version: '0.0.1',
-  })
-
-  server.tool(
-    'listTanStackIntegrations',
-    'List available integrations for creating TanStack applications',
-    {},
-    async () => {
-      try {
-        const manifest = await fetchManifest()
-        const integrations = manifest.integrations
-          .filter((a) => a.modes.includes('file-router'))
-          .map((integration) => ({
-            id: integration.id,
-            name: integration.name,
-            description: integration.description,
-            category: integration.category,
-            dependsOn: integration.dependsOn,
-            exclusive: integration.exclusive,
-            hasOptions: integration.hasOptions,
-          }))
-
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: JSON.stringify(integrations, null, 2),
-            },
-          ],
-        }
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Error fetching integrations: ${error}`,
-            },
-          ],
-        }
-      }
-    },
-  )
-
-  // Register documentation/ecosystem tools
-  registerDocTools(server)
-
-  server.tool(
-    'createTanStackApplication',
-    'Create a new TanStack Start application',
-    {
-      projectName: z
-        .string()
-        .describe('The name of the project (will be the directory name)'),
-      targetDir: z
-        .string()
-        .describe('Absolute path where the project should be created'),
-      integrations: z
-        .array(z.string())
-        .optional()
-        .describe(
-          'Array of integration IDs to include. Use listTanStackIntegrations to see available options.',
-        ),
-      integrationOptions: z
-        .record(z.record(z.unknown()))
-        .optional()
-        .describe(
-          'Configuration for integrations. Format: {"integrationId": {"optionName": "value"}}',
-        ),
-      tailwind: z.boolean().optional().describe('Include Tailwind CSS (default: true)'),
-      packageManager: z
-        .enum(['npm', 'pnpm', 'yarn', 'bun', 'deno'])
-        .optional()
-        .describe('Package manager to use (default: pnpm)'),
-    },
-    async ({ projectName, targetDir, integrations, integrationOptions, tailwind, packageManager }) => {
-      try {
-        const { mkdirSync, writeFileSync } = await import('node:fs')
-        const { resolve } = await import('node:path')
-        const { execSync } = await import('node:child_process')
-
-        // Fetch integration definitions if needed
-        let chosenIntegrations: Array<Awaited<ReturnType<typeof fetchIntegrations>>[number]> = []
-        if (integrations?.length) {
-          chosenIntegrations = await fetchIntegrations(integrations)
-        }
-
-        // Compile project
-        const output = compile({
-          projectName,
-          framework: 'react',
-          mode: 'file-router' as RouterMode,
-          typescript: true,
-          tailwind: tailwind ?? true,
-          packageManager: packageManager ?? 'pnpm',
-          chosenIntegrations,
-          integrationOptions: integrationOptions ?? {},
-        })
-
-        // Create directory and write files
-        mkdirSync(targetDir, { recursive: true })
-
-        for (const [filePath, content] of Object.entries(output.files)) {
-          const fullPath = resolve(targetDir, filePath)
-          const dir = resolve(fullPath, '..')
-          mkdirSync(dir, { recursive: true })
-          writeFileSync(fullPath, content, 'utf-8')
-        }
-
-        // Initialize git
-        try {
-          execSync('git init', { cwd: targetDir, stdio: 'ignore' })
-        } catch {
-          // Git init failed, continue anyway
-        }
-
-        // Build response
-        const envVarList =
-          output.envVars.length > 0
-            ? `\n\nRequired environment variables:\n${output.envVars.map((e) => `- ${e.name}: ${e.description}`).join('\n')}`
-            : ''
-
-        const warnings =
-          output.warnings.length > 0
-            ? `\n\nWarnings:\n${output.warnings.map((w) => `- ${w}`).join('\n')}`
-            : ''
-
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Project "${projectName}" created successfully at ${targetDir}
-
-Files created: ${Object.keys(output.files).length}
-Integrations included: ${chosenIntegrations.map((a) => a.name).join(', ') || 'none'}${envVarList}${warnings}
-
-Next steps:
-1. cd ${targetDir}
-2. ${packageManager ?? 'pnpm'} install
-3. ${packageManager ?? 'pnpm'} dev`,
-            },
-          ],
-        }
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Error creating application: ${error}`,
-            },
-          ],
-        }
-      }
-    },
-  )
-
-  return server
-}
-
-export async function runMcp(options: McpOptions): Promise<void> {
-  const server = createServer()
-
-  if (options.sse) {
-    const app = express()
-    let transport: SSEServerTransport | null = null
-
-    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 = parseInt(options.port ?? '8080', 10)
-    app.listen(port, () => {
-      console.log(`MCP server running at http://localhost:${port}/sse`)
-    })
-  } else {
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-  }
-}

package/src/engine/compile-with-addons.test.ts

@@ -1,302 +0,0 @@
-import { resolve } from 'node:path'
-import { beforeAll, describe, expect, it } from 'vitest'
-import { fetchIntegration, fetchIntegrations } from '../api/fetch.js'
-import { compile } from './compile.js'
-import type { CompileOptions, IntegrationCompiled } from './types.js'
-
-const INTEGRATIONS_PATH = resolve(__dirname, '../../../../integrations')
-
-const baseOptions: CompileOptions = {
-  projectName: 'test-project',
-  framework: 'react',
-  mode: 'file-router',
-  typescript: true,
-  tailwind: true,
-  packageManager: 'pnpm',
-  chosenIntegrations: [],
-  integrationOptions: {},
-}
-
-describe('compile with real integrations', () => {
-  describe('TanStack Query integration', () => {
-    let queryIntegration: IntegrationCompiled
-
-    beforeAll(async () => {
-      queryIntegration = await fetchIntegration('tanstack-query', INTEGRATIONS_PATH)
-    })
-
-    it('should load integration from local path', () => {
-      expect(queryIntegration.id).toBe('tanstack-query')
-      expect(queryIntegration.name).toBe('TanStack Query')
-      expect(queryIntegration.hooks).toHaveLength(2)
-    })
-
-    it('should have provider hook', () => {
-      const provider = queryIntegration.hooks?.find(
-        (i) => i.type === 'root-provider',
-      )
-      expect(provider).toBeDefined()
-      expect(provider?.jsName).toBe('QueryProvider')
-    })
-
-    it('should have devtools hook', () => {
-      const devtools = queryIntegration.hooks?.find(
-        (i) => i.type === 'devtools',
-      )
-      expect(devtools).toBeDefined()
-      expect(devtools?.jsName).toBe('queryDevtoolsPlugin')
-    })
-
-    it('should include integration files in compile output', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: [queryIntegration],
-      })
-
-      expect(output.files).toHaveProperty(
-        'src/integrations/query/provider.tsx',
-      )
-      expect(output.files).toHaveProperty(
-        'src/integrations/query/devtools.tsx',
-      )
-      expect(output.files).toHaveProperty('src/routes/demo/query.tsx')
-    })
-
-    it('should inject provider into __root.tsx', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: [queryIntegration],
-      })
-
-      const rootRoute = output.files['src/routes/__root.tsx']!
-      expect(rootRoute).toContain('QueryProvider')
-    })
-
-    it('should inject devtools into __root.tsx', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: [queryIntegration],
-      })
-
-      const rootRoute = output.files['src/routes/__root.tsx']!
-      expect(rootRoute).toContain('queryDevtoolsPlugin')
-    })
-  })
-
-  describe('Shadcn integration', () => {
-    let shadcnIntegration: IntegrationCompiled
-
-    beforeAll(async () => {
-      shadcnIntegration = await fetchIntegration('shadcn', INTEGRATIONS_PATH)
-    })
-
-    it('should load shadcn integration', () => {
-      expect(shadcnIntegration.id).toBe('shadcn')
-      expect(shadcnIntegration.name).toBe('shadcn/ui')
-    })
-
-    it('should include shadcn files', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: [shadcnIntegration],
-      })
-
-      // Shadcn should have components.json or similar config files
-      expect(Object.keys(output.files).some((f) => f.includes('components'))).toBe(true)
-    })
-  })
-
-  describe('Multiple integrations', () => {
-    let integrations: Array<IntegrationCompiled>
-
-    beforeAll(async () => {
-      integrations = await fetchIntegrations(
-        ['tanstack-query', 'tanstack-form'],
-        INTEGRATIONS_PATH,
-      )
-    })
-
-    it('should load multiple integrations', () => {
-      expect(integrations).toHaveLength(2)
-      expect(integrations.map((a) => a.id)).toEqual(['tanstack-query', 'tanstack-form'])
-    })
-
-    it('should compile with multiple integrations', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: integrations,
-      })
-
-      // Both integration files should be present
-      expect(output.files).toHaveProperty(
-        'src/integrations/query/provider.tsx',
-      )
-      // TanStack Form doesn't have a provider, just a demo route
-      expect(output.files).toHaveProperty(
-        'src/routes/demo/form.tsx',
-      )
-    })
-
-    it('should merge all integration dependencies', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: integrations,
-      })
-
-      // Check that dependencies from both integrations are merged
-      expect(output.packages.dependencies).toHaveProperty('@tanstack/react-query')
-      expect(output.packages.dependencies).toHaveProperty('@tanstack/react-form')
-    })
-  })
-
-  describe('Vite plugin integration (Sentry)', () => {
-    let sentryIntegration: IntegrationCompiled
-
-    beforeAll(async () => {
-      sentryIntegration = await fetchIntegration('sentry', INTEGRATIONS_PATH)
-    })
-
-    it('should load sentry integration', () => {
-      expect(sentryIntegration.id).toBe('sentry')
-    })
-
-    it('should inject vite plugin if sentry has one', () => {
-      const vitePlugin = sentryIntegration.hooks?.find(
-        (i) => i.type === 'vite-plugin',
-      )
-
-      if (vitePlugin) {
-        const output = compile({
-          ...baseOptions,
-          chosenIntegrations: [sentryIntegration],
-        })
-
-        const viteConfig = output.files['vite.config.ts']!
-        expect(viteConfig).toContain(vitePlugin.jsName || vitePlugin.code)
-      }
-    })
-  })
-
-  describe('Toolchain integration (ESLint)', () => {
-    let eslintIntegration: IntegrationCompiled
-
-    beforeAll(async () => {
-      eslintIntegration = await fetchIntegration('eslint', INTEGRATIONS_PATH)
-    })
-
-    it('should load eslint integration', () => {
-      expect(eslintIntegration.id).toBe('eslint')
-      expect(eslintIntegration.type).toBe('toolchain')
-      expect(eslintIntegration.phase).toBe('setup')
-    })
-
-    it('should add eslint config files', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: [eslintIntegration],
-      })
-
-      // ESLint should add config file
-      const hasEslintConfig = Object.keys(output.files).some(
-        (f) => f.includes('eslint') || f.includes('.eslintrc'),
-      )
-      expect(hasEslintConfig).toBe(true)
-    })
-
-    it('should add eslint scripts to package.json', () => {
-      const output = compile({
-        ...baseOptions,
-        chosenIntegrations: [eslintIntegration],
-      })
-
-      const pkg = JSON.parse(output.files['package.json']!)
-      expect(pkg.scripts.lint).toBeDefined()
-    })
-  })
-
-  describe('Deployment integration (Railway)', () => {
-    let railwayIntegration: IntegrationCompiled
-
-    beforeAll(async () => {
-      railwayIntegration = await fetchIntegration('railway', INTEGRATIONS_PATH)
-    })
-
-    it('should load railway integration', () => {
-      expect(railwayIntegration.id).toBe('railway')
-      expect(railwayIntegration.type).toBe('deployment')
-    })
-  })
-})
-
-describe('compile output validation', () => {
-  it('should generate valid vite.config.ts syntax', async () => {
-    const queryIntegration = await fetchIntegration('tanstack-query', INTEGRATIONS_PATH)
-    const output = compile({
-      ...baseOptions,
-      chosenIntegrations: [queryIntegration],
-    })
-
-    const viteConfig = output.files['vite.config.ts']!
-
-    // Basic syntax checks
-    expect(viteConfig).toContain('export default defineConfig')
-    expect(viteConfig).toContain('plugins:')
-
-    // Should have balanced braces
-    const openBraces = (viteConfig.match(/\{/g) || []).length
-    const closeBraces = (viteConfig.match(/\}/g) || []).length
-    expect(openBraces).toBe(closeBraces)
-
-    // Should have balanced brackets
-    const openBrackets = (viteConfig.match(/\[/g) || []).length
-    const closeBrackets = (viteConfig.match(/\]/g) || []).length
-    expect(openBrackets).toBe(closeBrackets)
-  })
-
-  it('should generate valid __root.tsx syntax', async () => {
-    const queryIntegration = await fetchIntegration('tanstack-query', INTEGRATIONS_PATH)
-    const output = compile({
-      ...baseOptions,
-      chosenIntegrations: [queryIntegration],
-    })
-
-    const rootRoute = output.files['src/routes/__root.tsx']!
-
-    // Basic syntax checks
-    expect(rootRoute).toContain('createRootRoute')
-    expect(rootRoute).toContain('export const Route')
-
-    // Should have balanced JSX tags (roughly - this is a simple check)
-    // Note: We only count React component tags (uppercase), not HTML tags (lowercase like html, head, body)
-    const openTags = (rootRoute.match(/<[A-Z][^/>]*>/g) || []).length
-    const closeTags = (rootRoute.match(/<\/[A-Z][^>]*>/g) || []).length
-    const selfClosingTags = (rootRoute.match(/<[A-Z][^>]*\/>/g) || []).length
-    // Open tags should equal close tags + self-closing tags (approximately)
-    // Allow tolerance of 4 due to complex provider nesting patterns
-    expect(Math.abs(openTags - closeTags - selfClosingTags)).toBeLessThanOrEqual(4)
-  })
-
-  it('should generate valid package.json', async () => {
-    const integrations = await fetchIntegrations(
-      ['tanstack-query', 'tanstack-form'],
-      INTEGRATIONS_PATH,
-    )
-    const output = compile({
-      ...baseOptions,
-      chosenIntegrations: integrations,
-    })
-
-    const pkg = JSON.parse(output.files['package.json']!)
-
-    // Required fields
-    expect(pkg.name).toBe('test-project')
-    expect(pkg.type).toBe('module')
-    expect(pkg.scripts).toBeDefined()
-    expect(pkg.dependencies).toBeDefined()
-    expect(pkg.devDependencies).toBeDefined()
-
-    // No duplicate keys (JSON.parse would fail otherwise, but let's be explicit)
-    expect(typeof pkg.dependencies).toBe('object')
-    expect(typeof pkg.devDependencies).toBe('object')
-  })
-})