@tanstack/cli 0.61.1 → 0.62.0

package/src/discovery.ts

@@ -1,209 +0,0 @@
-import { z } from 'zod'
-
-const TANSTACK_API_BASE = 'https://tanstack.com/api/data'
-
-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(),
-})
-
-const LibrariesResponseSchema = z.object({
-  libraries: z.array(LibrarySchema),
-  groups: z.record(z.array(z.string())),
-  groupNames: z.record(z.string()),
-})
-
-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(),
-})
-
-const PartnersResponseSchema = z.object({
-  partners: z.array(PartnerSchema),
-  categories: z.array(z.string()),
-  categoryLabels: z.record(z.string()),
-})
-
-export const LIBRARY_GROUPS = ['state', 'headlessUI', 'performance', 'tooling'] as const
-
-// Algolia config (public read-only keys)
-const ALGOLIA_APP_ID = 'FQ0DQ6MA3C'
-const ALGOLIA_API_KEY = '10c34d6a5c89f6048cf644d601e65172'
-const ALGOLIA_INDEX = 'tanstack-test'
-
-export type LibrariesResponse = z.infer<typeof LibrariesResponseSchema>
-export type PartnersResponse = z.infer<typeof PartnersResponseSchema>
-
-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()
-}
-
-export async function searchTanStackDocs({
-  query,
-  library,
-  framework,
-  limit = 10,
-}: {
-  query: string
-  library?: string
-  framework?: string
-  limit?: number
-}): Promise<{
-  query: string
-  totalHits: number
-  results: Array<{
-    title: string
-    url: string
-    snippet: string
-    library: string
-    breadcrumb: Array<string>
-  }>
-}> {
-  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']
-
-  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})`)
-  }
-
-  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) {
-    throw new Error(`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]
-
-  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 {
-    query,
-    totalHits: searchResult.nbHits || results.length,
-    results,
-  }
-}

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,
-    ],
-  })
-}