@tanstack/cli 0.0.1

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@tanstack/cli",
+  "version": "0.0.1",
+  "description": "TanStack CLI for scaffolding and tooling",
+  "author": "Tanner Linsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/cli.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://tanstack.com/cli",
+  "keywords": [
+    "tanstack",
+    "cli",
+    "scaffold",
+    "mcp",
+    "create",
+    "start"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "tanstack": "./dist/bin.mjs"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsdown --clean",
+    "test:types": "tsc --noEmit",
+    "test:eslint": "eslint ./src",
+    "test:lib": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "@modelcontextprotocol/sdk": "^1.6.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ejs": "^3.1.10",
+    "express": "^4.21.2",
+    "ignore": "^7.0.5",
+    "parse-gitignore": "^2.0.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/express": "^5.0.1",
+    "@types/node": "^25.0.7"
+  }
+}

package/src/api/fetch.test.ts

@@ -0,0 +1,114 @@
+import { resolve } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import {
+  fetchManifest,
+  fetchIntegration,
+  fetchIntegrations,
+  fetchIntegrationInfo,
+  fetchIntegrationFiles,
+} from './fetch.js'
+
+const INTEGRATIONS_PATH = resolve(__dirname, '../../../../integrations')
+
+describe('fetch API', () => {
+  describe('fetchManifest', () => {
+    it('should fetch manifest from local path', async () => {
+      const manifest = await fetchManifest(INTEGRATIONS_PATH)
+
+      expect(manifest).toBeDefined()
+      expect(manifest.integrations).toBeInstanceOf(Array)
+      expect(manifest.integrations.length).toBeGreaterThan(0)
+    })
+
+    it('should have integrations with required fields', async () => {
+      const manifest = await fetchManifest(INTEGRATIONS_PATH)
+
+      for (const integration of manifest.integrations) {
+        expect(integration.id).toBeDefined()
+        expect(integration.name).toBeDefined()
+        expect(integration.modes).toBeInstanceOf(Array)
+      }
+    })
+
+    it('should throw for non-existent path', async () => {
+      await expect(fetchManifest('/non/existent/path')).rejects.toThrow()
+    })
+  })
+
+  describe('fetchIntegrationInfo', () => {
+    it('should fetch integration info from local path', async () => {
+      const info = await fetchIntegrationInfo('tanstack-query', INTEGRATIONS_PATH)
+
+      expect(info.name).toBe('TanStack Query')
+      expect(info.type).toBe('integration')
+      expect(info.modes).toContain('file-router')
+    })
+
+    it('should throw for non-existent integration', async () => {
+      await expect(
+        fetchIntegrationInfo('non-existent', INTEGRATIONS_PATH),
+      ).rejects.toThrow()
+    })
+  })
+
+  describe('fetchIntegrationFiles', () => {
+    it('should fetch integration files from local path', async () => {
+      const files = await fetchIntegrationFiles('tanstack-query', INTEGRATIONS_PATH)
+
+      expect(Object.keys(files).length).toBeGreaterThan(0)
+      // Files are in assets/src/integrations/query/
+      expect(files).toHaveProperty('src/integrations/query/provider.tsx')
+    })
+
+    it('should return empty object for integration without assets', async () => {
+      // This tests the case where assets dir doesn't exist
+      const files = await fetchIntegrationFiles('non-existent', INTEGRATIONS_PATH)
+      expect(files).toEqual({})
+    })
+  })
+
+  describe('fetchIntegration', () => {
+    it('should fetch complete integration', async () => {
+      const integration = await fetchIntegration('tanstack-query', INTEGRATIONS_PATH)
+
+      expect(integration.id).toBe('tanstack-query')
+      expect(integration.name).toBe('TanStack Query')
+      expect(integration.files).toBeDefined()
+      expect(Object.keys(integration.files).length).toBeGreaterThan(0)
+    })
+
+    it('should include hooks if defined', async () => {
+      const integration = await fetchIntegration('tanstack-query', INTEGRATIONS_PATH)
+
+      expect(integration.hooks).toBeDefined()
+      expect(integration.hooks!.length).toBeGreaterThan(0)
+    })
+
+    it('should merge package.json into packageAdditions', async () => {
+      const integration = await fetchIntegration('tanstack-query', INTEGRATIONS_PATH)
+
+      expect(integration.packageAdditions).toBeDefined()
+      expect(integration.packageAdditions?.dependencies).toHaveProperty(
+        '@tanstack/react-query',
+      )
+    })
+  })
+
+  describe('fetchIntegrations', () => {
+    it('should fetch multiple integrations in parallel', async () => {
+      const integrations = await fetchIntegrations(
+        ['tanstack-query', 'tanstack-form'],
+        INTEGRATIONS_PATH,
+      )
+
+      expect(integrations).toHaveLength(2)
+      expect(integrations[0]?.id).toBe('tanstack-query')
+      expect(integrations[1]?.id).toBe('tanstack-form')
+    })
+
+    it('should return empty array for empty input', async () => {
+      const integrations = await fetchIntegrations([], INTEGRATIONS_PATH)
+      expect(integrations).toEqual([])
+    })
+  })
+})

package/src/api/fetch.ts

@@ -0,0 +1,221 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import {
+  IntegrationCompiledSchema,
+  IntegrationInfoSchema,
+  ManifestSchema
+} from '../engine/types.js'
+import type { IntegrationCompiled, IntegrationInfo, Manifest } from '../engine/types.js'
+
+const GITHUB_RAW_BASE =
+  'https://raw.githubusercontent.com/TanStack/cli/main/integrations'
+
+/**
+ * Check if a path is a local directory
+ */
+function isLocalPath(path: string): boolean {
+  return path.startsWith('/') || path.startsWith('./') || path.startsWith('..')
+}
+
+/**
+ * Fetch the integration manifest from GitHub or local path
+ */
+export async function fetchManifest(
+  baseUrl: string = GITHUB_RAW_BASE,
+): Promise<Manifest> {
+  if (isLocalPath(baseUrl)) {
+    const manifestPath = join(baseUrl, 'manifest.json')
+    if (!existsSync(manifestPath)) {
+      throw new Error(`Manifest not found at ${manifestPath}`)
+    }
+    const data = JSON.parse(readFileSync(manifestPath, 'utf-8'))
+    return ManifestSchema.parse(data)
+  }
+
+  const url = `${baseUrl}/manifest.json`
+  const response = await fetch(url)
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch manifest: ${response.statusText}`)
+  }
+
+  const data = await response.json()
+  return ManifestSchema.parse(data)
+}
+
+/**
+ * Fetch integration info.json from GitHub or local path
+ */
+export async function fetchIntegrationInfo(
+  integrationId: string,
+  baseUrl: string = GITHUB_RAW_BASE,
+): Promise<IntegrationInfo> {
+  if (isLocalPath(baseUrl)) {
+    const infoPath = join(baseUrl, integrationId, 'info.json')
+    if (!existsSync(infoPath)) {
+      throw new Error(`Integration info not found at ${infoPath}`)
+    }
+    const data = JSON.parse(readFileSync(infoPath, 'utf-8'))
+    return IntegrationInfoSchema.parse(data)
+  }
+
+  const url = `${baseUrl}/${integrationId}/info.json`
+  const response = await fetch(url)
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch integration ${integrationId}: ${response.statusText}`)
+  }
+
+  const data = await response.json()
+  return IntegrationInfoSchema.parse(data)
+}
+
+/**
+ * Recursively read all files from a directory
+ */
+function readDirRecursive(
+  dir: string,
+  basePath: string = '',
+): Record<string, string> {
+  const files: Record<string, string> = {}
+
+  if (!existsSync(dir)) return files
+
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry)
+    const relativePath = basePath ? `${basePath}/${entry}` : entry
+    const stat = statSync(fullPath)
+
+    if (stat.isDirectory()) {
+      Object.assign(files, readDirRecursive(fullPath, relativePath))
+    } else {
+      files[relativePath] = readFileSync(fullPath, 'utf-8')
+    }
+  }
+
+  return files
+}
+
+/**
+ * Fetch all files for an integration from GitHub or local path
+ */
+export async function fetchIntegrationFiles(
+  integrationId: string,
+  baseUrl: string = GITHUB_RAW_BASE,
+): Promise<Record<string, string>> {
+  if (isLocalPath(baseUrl)) {
+    const assetsPath = join(baseUrl, integrationId, 'assets')
+    return readDirRecursive(assetsPath)
+  }
+
+  // First fetch the file list (we'll need a files.json or similar)
+  const filesUrl = `${baseUrl}/${integrationId}/files.json`
+  const response = await fetch(filesUrl)
+
+  if (!response.ok) {
+    // No files.json, return empty
+    return {}
+  }
+
+  const fileList: Array<string> = await response.json()
+  const files: Record<string, string> = {}
+
+  // Fetch each file
+  await Promise.all(
+    fileList.map(async (filePath) => {
+      const fileUrl = `${baseUrl}/${integrationId}/assets/${filePath}`
+      const fileResponse = await fetch(fileUrl)
+
+      if (fileResponse.ok) {
+        files[filePath] = await fileResponse.text()
+      }
+    }),
+  )
+
+  return files
+}
+
+/**
+ * Fetch integration package.json if it exists
+ */
+async function fetchIntegrationPackageJson(
+  integrationId: string,
+  baseUrl: string,
+): Promise<{
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  scripts?: Record<string, string>
+} | null> {
+  if (isLocalPath(baseUrl)) {
+    const pkgPath = join(baseUrl, integrationId, 'package.json')
+    if (existsSync(pkgPath)) {
+      return JSON.parse(readFileSync(pkgPath, 'utf-8'))
+    }
+    return null
+  }
+
+  const url = `${baseUrl}/${integrationId}/package.json`
+  const response = await fetch(url)
+
+  if (!response.ok) {
+    return null
+  }
+
+  return response.json()
+}
+
+/**
+ * Fetch a complete compiled integration from GitHub
+ */
+export async function fetchIntegration(
+  integrationId: string,
+  baseUrl: string = GITHUB_RAW_BASE,
+): Promise<IntegrationCompiled> {
+  const [info, files, pkgJson] = await Promise.all([
+    fetchIntegrationInfo(integrationId, baseUrl),
+    fetchIntegrationFiles(integrationId, baseUrl),
+    fetchIntegrationPackageJson(integrationId, baseUrl),
+  ])
+
+  // Merge package.json into packageAdditions if present
+  const packageAdditions = info.packageAdditions ?? {}
+  if (pkgJson) {
+    if (pkgJson.dependencies) {
+      packageAdditions.dependencies = {
+        ...packageAdditions.dependencies,
+        ...pkgJson.dependencies,
+      }
+    }
+    if (pkgJson.devDependencies) {
+      packageAdditions.devDependencies = {
+        ...packageAdditions.devDependencies,
+        ...pkgJson.devDependencies,
+      }
+    }
+    if (pkgJson.scripts) {
+      packageAdditions.scripts = {
+        ...packageAdditions.scripts,
+        ...pkgJson.scripts,
+      }
+    }
+  }
+
+  return IntegrationCompiledSchema.parse({
+    ...info,
+    id: integrationId,
+    files,
+    packageAdditions:
+      Object.keys(packageAdditions).length > 0 ? packageAdditions : undefined,
+    deletedFiles: [],
+  })
+}
+
+/**
+ * Fetch multiple integrations in parallel
+ */
+export async function fetchIntegrations(
+  integrationIds: Array<string>,
+  baseUrl: string = GITHUB_RAW_BASE,
+): Promise<Array<IntegrationCompiled>> {
+  return Promise.all(integrationIds.map((id) => fetchIntegration(id, baseUrl)))
+}

package/src/bin.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+import { resolve } from 'node:path'
+import { Command } from 'commander'
+import { runCreate } from './commands/create.js'
+import { runMcp } from './commands/mcp.js'
+import { compileIntegration, initIntegration } from './engine/custom-addons/integration.js'
+import { compileTemplate, initTemplate } from './engine/custom-addons/template.js'
+
+const program = new Command()
+
+program
+  .name('tanstack')
+  .description('TanStack CLI for scaffolding and tooling')
+  .version('0.0.1')
+
+program
+  .command('create')
+  .argument('[project-name]', 'name of the project')
+  .option('--template <template>', 'URL to a custom template JSON file')
+  .option('--package-manager <pm>', 'package manager (npm, pnpm, yarn, bun)')
+  .option('--integrations <integrations>', 'comma-separated list of integration IDs')
+  .option('--no-install', 'skip installing dependencies')
+  .option('--no-git', 'skip initializing git repository')
+  .option('--no-tailwind', 'skip tailwind CSS')
+  .option('-y, --yes', 'skip prompts and use defaults')
+  .option('--target-dir <path>', 'target directory for the project')
+  .option('--integrations-path <path>', 'local path to integrations directory (for development)')
+  .description('Create a new TanStack Start project')
+  .action(runCreate)
+
+program
+  .command('mcp')
+  .option('--sse', 'run in SSE mode (for HTTP transport)')
+  .option('--port <port>', 'port for SSE server', '8080')
+  .description('Start the MCP server for AI agents')
+  .action(runMcp)
+
+// Integration commands
+const integrationCommand = program.command('integration')
+
+integrationCommand
+  .command('init')
+  .option('--integrations-path <path>', 'local path to integrations directory (for development)')
+  .description('Initialize an integration from the current project')
+  .action(async (options: { integrationsPath?: string }) => {
+    try {
+      await initIntegration(resolve(process.cwd()), options.integrationsPath)
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : 'An error occurred')
+      process.exit(1)
+    }
+  })
+
+integrationCommand
+  .command('compile')
+  .option('--integrations-path <path>', 'local path to integrations directory (for development)')
+  .description('Compile/update the integration from the current project')
+  .action(async (options: { integrationsPath?: string }) => {
+    try {
+      await compileIntegration(resolve(process.cwd()), options.integrationsPath)
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : 'An error occurred')
+      process.exit(1)
+    }
+  })
+
+// Custom template commands
+const templateCommand = program.command('template')
+
+templateCommand
+  .command('init')
+  .description('Initialize a custom template from the current project')
+  .action(async () => {
+    try {
+      await initTemplate(resolve(process.cwd()))
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : 'An error occurred')
+      process.exit(1)
+    }
+  })
+
+templateCommand
+  .command('compile')
+  .description('Compile/update the custom template from the current project')
+  .action(async () => {
+    try {
+      await compileTemplate(resolve(process.cwd()))
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : 'An error occurred')
+      process.exit(1)
+    }
+  })
+
+program.parse()