@tanstack/cli 0.0.8 → 0.48.3

package/src/file-syncer.ts

@@ -0,0 +1,205 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import * as diff from 'diff'
+
+export interface FileUpdate {
+  path: string
+  diff?: string
+}
+
+export interface SyncResult {
+  updated: Array<FileUpdate>
+  skipped: Array<string>
+  created: Array<string>
+  errors: Array<string>
+}
+
+export class FileSyncer {
+  async sync(sourceDir: string, targetDir: string): Promise<SyncResult> {
+    const result: SyncResult = {
+      updated: [],
+      skipped: [],
+      created: [],
+      errors: [],
+    }
+
+    // Ensure directories exist
+    if (!fs.existsSync(sourceDir)) {
+      throw new Error(`Source directory does not exist: ${sourceDir}`)
+    }
+    if (!fs.existsSync(targetDir)) {
+      throw new Error(`Target directory does not exist: ${targetDir}`)
+    }
+
+    // Walk through source directory and sync files
+    await this.syncDirectory(sourceDir, targetDir, sourceDir, result)
+
+    return result
+  }
+
+  private async syncDirectory(
+    currentPath: string,
+    targetBase: string,
+    sourceBase: string,
+    result: SyncResult,
+  ): Promise<void> {
+    const entries = await fs.promises.readdir(currentPath, {
+      withFileTypes: true,
+    })
+
+    for (const entry of entries) {
+      const sourcePath = path.join(currentPath, entry.name)
+      const relativePath = path.relative(sourceBase, sourcePath)
+      const targetPath = path.join(targetBase, relativePath)
+
+      // Skip certain directories
+      if (entry.isDirectory()) {
+        if (this.shouldSkipDirectory(entry.name)) {
+          continue
+        }
+
+        // Ensure target directory exists
+        if (!fs.existsSync(targetPath)) {
+          await fs.promises.mkdir(targetPath, { recursive: true })
+        }
+
+        // Recursively sync subdirectory
+        await this.syncDirectory(sourcePath, targetBase, sourceBase, result)
+      } else if (entry.isFile()) {
+        // Skip certain files
+        if (this.shouldSkipFile(entry.name)) {
+          continue
+        }
+
+        try {
+          const shouldUpdate = await this.shouldUpdateFile(
+            sourcePath,
+            targetPath,
+          )
+
+          if (shouldUpdate) {
+            // Check if file exists to generate diff
+            let fileDiff: string | undefined
+            const targetExists = fs.existsSync(targetPath)
+
+            if (targetExists) {
+              // Generate diff for existing files
+              const oldContent = await fs.promises.readFile(targetPath, 'utf-8')
+              const newContent = await fs.promises.readFile(sourcePath, 'utf-8')
+
+              const changes = diff.createPatch(
+                relativePath,
+                oldContent,
+                newContent,
+                'Previous',
+                'Current',
+              )
+
+              // Only include diff if there are actual changes
+              if (changes && changes.split('\n').length > 5) {
+                fileDiff = changes
+              }
+            }
+
+            // Copy file
+            await fs.promises.copyFile(sourcePath, targetPath)
+
+            // Touch file to trigger dev server reload
+            const now = new Date()
+            await fs.promises.utimes(targetPath, now, now)
+
+            if (!targetExists) {
+              result.created.push(relativePath)
+            } else {
+              result.updated.push({
+                path: relativePath,
+                diff: fileDiff,
+              })
+            }
+          } else {
+            result.skipped.push(relativePath)
+          }
+        } catch (error) {
+          result.errors.push(
+            `${relativePath}: ${error instanceof Error ? error.message : String(error)}`,
+          )
+        }
+      }
+    }
+  }
+
+  private async shouldUpdateFile(
+    sourcePath: string,
+    targetPath: string,
+  ): Promise<boolean> {
+    // If target doesn't exist, definitely update
+    if (!fs.existsSync(targetPath)) {
+      return true
+    }
+
+    // Compare file sizes first (quick check)
+    const [sourceStats, targetStats] = await Promise.all([
+      fs.promises.stat(sourcePath),
+      fs.promises.stat(targetPath),
+    ])
+
+    if (sourceStats.size !== targetStats.size) {
+      return true
+    }
+
+    // Compare MD5 hashes for content
+    const [sourceHash, targetHash] = await Promise.all([
+      this.calculateHash(sourcePath),
+      this.calculateHash(targetPath),
+    ])
+
+    return sourceHash !== targetHash
+  }
+
+  private async calculateHash(filePath: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('md5')
+      const stream = fs.createReadStream(filePath)
+
+      stream.on('data', (data) => hash.update(data))
+      stream.on('end', () => resolve(hash.digest('hex')))
+      stream.on('error', reject)
+    })
+  }
+
+  private shouldSkipDirectory(name: string): boolean {
+    const skipDirs = [
+      'node_modules',
+      '.git',
+      'dist',
+      'build',
+      '.next',
+      '.nuxt',
+      '.cache',
+      '.tmp-dev',
+      'coverage',
+      '.turbo',
+    ]
+
+    return skipDirs.includes(name) || name.startsWith('.')
+  }
+
+  private shouldSkipFile(name: string): boolean {
+    const skipFiles = [
+      '.DS_Store',
+      'Thumbs.db',
+      'desktop.ini',
+      '.cta.json', // Skip .cta.json as it contains framework ID that changes each build
+    ]
+
+    const skipExtensions = ['.log', '.lock', '.pid', '.seed', '.sqlite']
+
+    if (skipFiles.includes(name)) {
+      return true
+    }
+
+    const ext = path.extname(name).toLowerCase()
+    return skipExtensions.includes(ext)
+  }
+}

package/src/index.ts

@@ -1,85 +1 @@
-// Engine exports
-export { compile, compileWithAttribution } from './engine/compile.js'
-export { processTemplateFile, relativePath } from './engine/template.js'
-
-// Config file exports
-export {
-  CONFIG_FILE,
-  writeConfigFile,
-  readConfigFile,
-} from './engine/config-file.js'
-export type { PersistedOptions } from './engine/config-file.js'
-
-// Custom integration/template exports
-export { initIntegration, compileIntegration, loadRemoteIntegration } from './engine/custom-addons/integration.js'
-export { initTemplate, compileTemplate, loadTemplate } from './engine/custom-addons/template.js'
-
-// API exports
-export {
-  fetchManifest,
-  fetchIntegration,
-  fetchIntegrations,
-  fetchIntegrationInfo,
-  fetchIntegrationFiles,
-} from './api/fetch.js'
-
-// Type exports
-export type {
-  // Core types
-  PackageManager,
-  Category,
-  IntegrationType,
-  IntegrationPhase,
-  RouterMode,
-
-  // Option types
-  IntegrationOption,
-  IntegrationOptions,
-
-  // Hook types (code injection points)
-  HookType,
-  Hook,
-  Route,
-  EnvVar,
-  Command,
-
-  // Integration types
-  IntegrationInfo,
-  IntegrationCompiled,
-  CustomTemplateInfo,
-  CustomTemplateCompiled,
-
-  // Manifest types
-  ManifestIntegration,
-  Manifest,
-
-  // Project types
-  ProjectDefinition,
-  CompileOptions,
-  CompileOutput,
-
-  // Attribution types
-  LineAttribution,
-  AttributedFile,
-  AttributedCompileOutput,
-} from './engine/types.js'
-
-// Schema exports (for validation)
-export {
-  CategorySchema,
-  IntegrationTypeSchema,
-  IntegrationPhaseSchema,
-  RouterModeSchema,
-  IntegrationOptionSchema,
-  IntegrationOptionsSchema,
-  HookSchema,
-  RouteSchema,
-  EnvVarSchema,
-  CommandSchema,
-  IntegrationInfoSchema,
-  IntegrationCompiledSchema,
-  CustomTemplateInfoSchema,
-  CustomTemplateCompiledSchema,
-  ManifestIntegrationSchema,
-  ManifestSchema,
-} from './engine/types.js'
+export { cli } from './cli.js'

package/src/mcp.ts

@@ -0,0 +1,190 @@
+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,
+                  options: addOn.options,
+                  dependsOn: addOn.dependsOn,
+                })),
+            ),
+          },
+        ],
+      }
+    },
+  )
+
+  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,
+  }: {
+    forcedMode?: string
+    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)
+  }
+}