@tanstack/cli 0.60.1 → 0.62.0

package/src/file-syncer.ts

@@ -1,263 +0,0 @@
-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>
-  deleted: Array<string>
-  sourceFiles: Array<string>
-  errors: Array<string>
-}
-
-export interface SyncOptions {
-  deleteRemoved?: boolean
-  previousSourceFiles?: Set<string>
-}
-
-export class FileSyncer {
-  async sync(
-    sourceDir: string,
-    targetDir: string,
-    options?: SyncOptions,
-  ): Promise<SyncResult> {
-    const result: SyncResult = {
-      updated: [],
-      skipped: [],
-      created: [],
-      deleted: [],
-      sourceFiles: [],
-      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)
-
-    if (options?.deleteRemoved && options.previousSourceFiles) {
-      const currentSourceFileSet = new Set(result.sourceFiles)
-      await this.deleteRemovedFiles(
-        targetDir,
-        options.previousSourceFiles,
-        currentSourceFileSet,
-        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
-        }
-
-        result.sourceFiles.push(relativePath)
-
-        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)
-  }
-
-  private async deleteRemovedFiles(
-    targetDir: string,
-    previousSourceFiles: Set<string>,
-    currentSourceFiles: Set<string>,
-    result: SyncResult,
-  ): Promise<void> {
-    for (const relativePath of previousSourceFiles) {
-      if (currentSourceFiles.has(relativePath)) {
-        continue
-      }
-
-      const targetPath = path.join(targetDir, relativePath)
-
-      try {
-        if (!fs.existsSync(targetPath)) {
-          continue
-        }
-
-        const stats = await fs.promises.stat(targetPath)
-        if (!stats.isFile()) {
-          continue
-        }
-
-        await fs.promises.unlink(targetPath)
-        result.deleted.push(relativePath)
-      } catch (error) {
-        result.errors.push(
-          `${relativePath}: ${error instanceof Error ? error.message : String(error)}`,
-        )
-      }
-    }
-  }
-}

package/src/index.ts

@@ -1,21 +0,0 @@
-import { pathToFileURL } from 'node:url'
-import {
-  createReactFrameworkDefinition,
-  createSolidFrameworkDefinition,
-} from '@tanstack/create'
-
-import { cli } from './cli.js'
-
-export { cli }
-
-const entryPath = process.argv[1]
-if (entryPath && import.meta.url === pathToFileURL(entryPath).href) {
-  cli({
-    name: 'tanstack',
-    appName: 'TanStack',
-    frameworkDefinitionInitializers: [
-      createReactFrameworkDefinition,
-      createSolidFrameworkDefinition,
-    ],
-  })
-}

package/src/mcp/api.ts

@@ -1,42 +0,0 @@
-import { LibrariesResponseSchema, PartnersResponseSchema } from './types.js'
-import type { LibrariesResponse, PartnersResponse } from './types.js'
-
-const TANSTACK_API_BASE = 'https://tanstack.com/api/data'
-
-export async function fetchLibraries(): Promise<LibrariesResponse> {
-  const response = await fetch(`${TANSTACK_API_BASE}/libraries`)
-  if (!response.ok) {
-    throw new Error(`Failed to fetch libraries: ${response.statusText}`)
-  }
-  const data = await response.json()
-  return LibrariesResponseSchema.parse(data)
-}
-
-export async function fetchPartners(): Promise<PartnersResponse> {
-  const response = await fetch(`${TANSTACK_API_BASE}/partners`)
-  if (!response.ok) {
-    throw new Error(`Failed to fetch partners: ${response.statusText}`)
-  }
-  const data = await response.json()
-  return PartnersResponseSchema.parse(data)
-}
-
-export async function fetchDocContent(
-  repo: string,
-  branch: string,
-  filePath: string,
-): Promise<string | null> {
-  const url = `https://raw.githubusercontent.com/${repo}/${branch}/${filePath}`
-  const response = await fetch(url, {
-    headers: { 'User-Agent': 'tanstack-cli' },
-  })
-
-  if (!response.ok) {
-    if (response.status === 404) {
-      return null
-    }
-    throw new Error(`Failed to fetch doc: ${response.statusText}`)
-  }
-
-  return response.text()
-}

package/src/mcp/tools.ts

@@ -1,323 +0,0 @@
-import { z } from 'zod'
-import { fetchDocContent, fetchLibraries, fetchPartners } from './api.js'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-
-// Algolia config (public read-only keys)
-const ALGOLIA_APP_ID = 'FQ0DQ6MA3C'
-const ALGOLIA_API_KEY = '10c34d6a5c89f6048cf644d601e65172'
-const ALGOLIA_INDEX = 'tanstack-test'
-
-const GROUP_KEYS = ['state', 'headlessUI', 'performance', 'tooling'] as const
-
-function jsonResult(data: unknown) {
-  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] }
-}
-
-function errorResult(error: string) {
-  return { content: [{ type: 'text' as const, text: `Error: ${error}` }], isError: true }
-}
-
-export function registerDocTools(server: McpServer) {
-  // Tool: tanstack_list_libraries
-  server.tool(
-    'tanstack_list_libraries',
-    'List TanStack libraries with metadata, frameworks, and docs URLs.',
-    {
-      group: z
-        .enum(GROUP_KEYS)
-        .optional()
-        .describe('Filter libraries by group. Options: state, headlessUI, performance, tooling'),
-    },
-    async ({ group }) => {
-      try {
-        const data = await fetchLibraries()
-        let libraries = data.libraries
-
-        if (group && data.groups[group]) {
-          const groupIds = data.groups[group]
-          libraries = libraries.filter((lib) => groupIds.includes(lib.id))
-        }
-
-        const groupName = group ? data.groupNames[group] || group : 'All Libraries'
-
-        return jsonResult({
-          group: groupName,
-          count: libraries.length,
-          libraries: libraries.map((lib) => ({
-            id: lib.id,
-            name: lib.name,
-            tagline: lib.tagline,
-            description: lib.description,
-            frameworks: lib.frameworks,
-            latestVersion: lib.latestVersion,
-            docsUrl: lib.docsUrl,
-            githubUrl: lib.githubUrl,
-          })),
-        })
-      } catch (error) {
-        return errorResult(String(error))
-      }
-    },
-  )
-
-  // Tool: tanstack_doc
-  server.tool(
-    'tanstack_doc',
-    'Fetch a TanStack documentation page by library and path.',
-    {
-      library: z.string().describe('Library ID (e.g., query, router, table, form)'),
-      path: z.string().describe('Documentation path (e.g., framework/react/overview)'),
-      version: z.string().optional().describe('Version (e.g., v5, v1). Defaults to latest'),
-    },
-    async ({ library: libraryId, path, version = 'latest' }) => {
-      try {
-        const data = await fetchLibraries()
-        const library = data.libraries.find((l) => l.id === libraryId)
-
-        if (!library) {
-          return errorResult(
-            `Library "${libraryId}" not found. Use tanstack_list_libraries to see available libraries.`,
-          )
-        }
-
-        if (version !== 'latest' && !library.availableVersions.includes(version)) {
-          return errorResult(
-            `Version "${version}" not found for ${library.name}. Available: ${library.availableVersions.join(', ')}`,
-          )
-        }
-
-        // Resolve branch
-        const branch =
-          version === 'latest' || version === library.latestVersion
-            ? library.latestBranch || 'main'
-            : version
-
-        const docsRoot = library.docsRoot || 'docs'
-        const filePath = `${docsRoot}/${path}.md`
-        const content = await fetchDocContent(library.repo, branch, filePath)
-
-        if (!content) {
-          return errorResult(
-            `Document not found: ${library.name} / ${path} (version: ${version})`,
-          )
-        }
-
-        // Extract frontmatter title if present
-        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/)
-        let title = path.split('/').pop() || 'Untitled'
-        let docContent = content
-
-        if (frontmatterMatch && frontmatterMatch[1]) {
-          const frontmatter = frontmatterMatch[1]
-          const titleMatch = frontmatter.match(/title:\s*['"]?([^'"\n]+)['"]?/)
-          if (titleMatch && titleMatch[1]) {
-            title = titleMatch[1]
-          }
-          docContent = content.slice(frontmatterMatch[0].length).trim()
-        }
-
-        return jsonResult({
-          title,
-          content: docContent,
-          url: `https://tanstack.com/${libraryId}/${version}/docs/${path}`,
-          library: library.name,
-          version: version === 'latest' ? library.latestVersion : version,
-        })
-      } catch (error) {
-        return errorResult(String(error))
-      }
-    },
-  )
-
-  // Tool: tanstack_search_docs
-  server.tool(
-    'tanstack_search_docs',
-    'Search TanStack documentation. Returns matching pages with snippets.',
-    {
-      query: z.string().describe('Search query'),
-      library: z.string().optional().describe('Filter to specific library (e.g., query, router)'),
-      framework: z
-        .string()
-        .optional()
-        .describe('Filter to specific framework (e.g., react, vue, solid)'),
-      limit: z
-        .number()
-        .min(1)
-        .max(50)
-        .optional()
-        .describe('Maximum number of results (default: 10, max: 50)'),
-    },
-    async ({ query, library, framework, limit = 10 }) => {
-      try {
-        const ALL_LIBRARIES = [
-          'config', 'form', 'optimistic', 'pacer', 'query', 'ranger',
-          'react-charts', 'router', 'start', 'store', 'table', 'virtual', 'db', 'devtools',
-        ]
-        const ALL_FRAMEWORKS = ['react', 'vue', 'solid', 'svelte', 'angular']
-
-        // Build filters
-        const filterParts: Array<string> = ['version:latest']
-
-        if (library) {
-          const otherLibraries = ALL_LIBRARIES.filter((l) => l !== library)
-          const exclusions = otherLibraries.map((l) => `NOT library:${l}`).join(' AND ')
-          if (exclusions) filterParts.push(`(${exclusions})`)
-        }
-
-        if (framework) {
-          const otherFrameworks = ALL_FRAMEWORKS.filter((f) => f !== framework)
-          const exclusions = otherFrameworks.map((f) => `NOT framework:${f}`).join(' AND ')
-          if (exclusions) filterParts.push(`(${exclusions})`)
-        }
-
-        // Call Algolia REST API directly
-        const searchParams = {
-          requests: [
-            {
-              indexName: ALGOLIA_INDEX,
-              query,
-              hitsPerPage: Math.min(limit, 50),
-              filters: filterParts.join(' AND '),
-              attributesToRetrieve: ['hierarchy', 'url', 'content', 'library'],
-              attributesToSnippet: ['content:80'],
-            },
-          ],
-        }
-
-        const response = await fetch(
-          `https://${ALGOLIA_APP_ID}-dsn.algolia.net/1/indexes/*/queries`,
-          {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-Algolia-Application-Id': ALGOLIA_APP_ID,
-              'X-Algolia-API-Key': ALGOLIA_API_KEY,
-            },
-            body: JSON.stringify(searchParams),
-          },
-        )
-
-        if (!response.ok) {
-          return errorResult(`Algolia search failed: ${response.statusText}`)
-        }
-
-        const searchResponse = await response.json() as {
-          results: Array<{
-            hits: Array<{
-              objectID: string
-              url: string
-              library?: string
-              hierarchy: Record<string, string | undefined>
-              content?: string
-              _snippetResult?: { content?: { value?: string } }
-            }>
-            nbHits?: number
-          }>
-        }
-
-        const searchResult = searchResponse.results[0]
-        if (!searchResult) {
-          return jsonResult({ query, totalHits: 0, results: [] })
-        }
-
-        const results = searchResult.hits.map((hit) => {
-          const breadcrumb = Object.values(hit.hierarchy).filter((v): v is string => Boolean(v))
-          return {
-            title: hit.hierarchy.lvl1 || hit.hierarchy.lvl0 || 'Untitled',
-            url: hit.url,
-            snippet: hit._snippetResult?.content?.value || hit.content || '',
-            library: hit.library || 'unknown',
-            breadcrumb,
-          }
-        })
-
-        return jsonResult({
-          query,
-          totalHits: searchResult.nbHits || results.length,
-          results,
-        })
-      } catch (error) {
-        return errorResult(String(error))
-      }
-    },
-  )
-
-  // Tool: tanstack_ecosystem
-  server.tool(
-    'tanstack_ecosystem',
-    'Ecosystem partner recommendations. Filter by category (database, auth, deployment, monitoring, cms, api, data-grid) or library.',
-    {
-      category: z
-        .string()
-        .optional()
-        .describe(
-          'Filter by category: database, auth, deployment, monitoring, cms, api, data-grid, code-review, learning',
-        ),
-      library: z
-        .string()
-        .optional()
-        .describe('Filter by TanStack library (e.g., start, router, query, table)'),
-    },
-    async ({ category, library }) => {
-      try {
-        const data = await fetchPartners()
-
-        // Category aliases
-        const categoryAliases: Record<string, string> = {
-          db: 'database',
-          postgres: 'database',
-          sql: 'database',
-          login: 'auth',
-          authentication: 'auth',
-          hosting: 'deployment',
-          deploy: 'deployment',
-          serverless: 'deployment',
-          errors: 'monitoring',
-          logging: 'monitoring',
-          content: 'cms',
-          'api-keys': 'api',
-          grid: 'data-grid',
-          review: 'code-review',
-          courses: 'learning',
-        }
-
-        let resolvedCategory: string | undefined
-        if (category) {
-          const normalized = category.toLowerCase().trim()
-          resolvedCategory = categoryAliases[normalized] || normalized
-          if (!data.categories.includes(resolvedCategory)) {
-            resolvedCategory = undefined
-          }
-        }
-
-        const lib = library?.toLowerCase().trim()
-
-        const partners = data.partners
-          .filter((p) => !resolvedCategory || p.category === resolvedCategory)
-          .filter((p) => !lib || p.libraries.some((l) => l === lib))
-          .map((p) => ({
-            id: p.id,
-            name: p.name,
-            tagline: p.tagline,
-            description: p.description,
-            category: p.category,
-            categoryLabel: p.categoryLabel,
-            url: p.url,
-            libraries: p.libraries,
-          }))
-
-        return jsonResult({
-          query: {
-            category,
-            categoryResolved: resolvedCategory,
-            library,
-          },
-          count: partners.length,
-          partners,
-        })
-      } catch (error) {
-        return errorResult(String(error))
-      }
-    },
-  )
-}

package/src/mcp/types.ts

@@ -1,46 +0,0 @@
-import { z } from 'zod'
-
-// API response types from tanstack.com
-export const LibrarySchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  tagline: z.string(),
-  description: z.string().optional(),
-  frameworks: z.array(z.string()),
-  latestVersion: z.string(),
-  latestBranch: z.string().optional(),
-  availableVersions: z.array(z.string()),
-  repo: z.string(),
-  docsRoot: z.string().optional(),
-  defaultDocs: z.string().optional(),
-  docsUrl: z.string().optional(),
-  githubUrl: z.string().optional(),
-})
-
-export const LibrariesResponseSchema = z.object({
-  libraries: z.array(LibrarySchema),
-  groups: z.record(z.array(z.string())),
-  groupNames: z.record(z.string()),
-})
-
-export const PartnerSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  tagline: z.string().optional(),
-  description: z.string(),
-  category: z.string(),
-  categoryLabel: z.string(),
-  libraries: z.array(z.string()),
-  url: z.string(),
-})
-
-export const PartnersResponseSchema = z.object({
-  partners: z.array(PartnerSchema),
-  categories: z.array(z.string()),
-  categoryLabels: z.record(z.string()),
-})
-
-export type Library = z.infer<typeof LibrarySchema>
-export type LibrariesResponse = z.infer<typeof LibrariesResponseSchema>
-export type Partner = z.infer<typeof PartnerSchema>
-export type PartnersResponse = z.infer<typeof PartnersResponseSchema>