@tanstack/cli 0.0.2 → 0.0.4

package/dist/{template-2SxOxCJc.mjs → template-BgEATWaG.mjs}

@@ -5,6 +5,7 @@ import { basename, dirname, extname, join, resolve } from "node:path";
 import { z } from "zod";
 import ignore from "ignore";
 import parseGitignore from "parse-gitignore";
+import { homedir } from "node:os";
 
 //#region src/engine/template.ts
 /**
@@ -1354,6 +1355,7 @@ ${packageManager}${packageManager === "npm" ? " run" : ""} dev
 - [TanStack Start Documentation](https://tanstack.com/start)
 - [TanStack Router Documentation](https://tanstack.com/router)
 `;
+	files[".nvmrc"] = "23";
 	return files;
 }
 /**
@@ -1461,8 +1463,8 @@ function buildPackageJson(options, packages) {
 			"@tanstack/react-router": "^1.132.0",
 			"@tanstack/react-router-devtools": "^1.132.0",
 			"@tanstack/react-start": "^1.132.0",
-			react: "^19.0.0",
-			"react-dom": "^19.0.0",
+			react: "^19.2.0",
+			"react-dom": "^19.2.0",
 			"vite-tsconfig-paths": "^5.1.4",
 			...hasHeader ? { "lucide-react": "^0.468.0" } : {},
 			...packages.dependencies
@@ -1471,8 +1473,8 @@ function buildPackageJson(options, packages) {
 			"@vitejs/plugin-react": "^4.4.1",
 			vite: "^7.0.0",
 			...options.typescript ? {
-				"@types/react": "^19.0.0",
-				"@types/react-dom": "^19.0.0",
+				"@types/react": "^19.2.0",
+				"@types/react-dom": "^19.2.0",
 				typescript: "^5.7.0"
 			} : {},
 			...options.tailwind ? {
@@ -1896,7 +1898,7 @@ const IntegrationInfoSchema = z.object({
 	requiresTailwind: z.boolean().optional(),
 	demoRequiresTailwind: z.boolean().optional(),
 	dependsOn: z.array(z.string()).optional(),
-	conflicts: z.array(z.string()).optional(),
+	exclusive: z.array(z.string()).optional(),
 	partnerId: z.string().optional(),
 	options: IntegrationOptionsSchema.optional(),
 	hooks: z.array(HookSchema).optional(),
@@ -1943,7 +1945,7 @@ const ManifestIntegrationSchema = z.object({
 	category: CategorySchema.optional(),
 	modes: z.array(RouterModeSchema),
 	dependsOn: z.array(z.string()).optional(),
-	conflicts: z.array(z.string()).optional(),
+	exclusive: z.array(z.string()).optional(),
 	partnerId: z.string().optional(),
 	hasOptions: z.boolean().optional(),
 	link: z.string().optional(),
@@ -1966,9 +1968,50 @@ const ManifestSchema = z.object({
 	customTemplates: z.array(ManifestCustomTemplateSchema).optional()
 });
 
+//#endregion
+//#region src/cache/index.ts
+const CACHE_DIR = join(homedir(), ".tanstack", "cache");
+const DEFAULT_TTL_MS = 1440 * 60 * 1e3;
+function ensureCacheDir() {
+	if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+}
+function getCachePath(key) {
+	return join(CACHE_DIR, `${key.replace(/[^a-zA-Z0-9-_]/g, "_")}.json`);
+}
+function getCached(key) {
+	const cachePath = getCachePath(key);
+	if (!existsSync(cachePath)) return null;
+	try {
+		const raw = readFileSync(cachePath, "utf-8");
+		const entry = JSON.parse(raw);
+		if (Date.now() - entry.timestamp > entry.ttl) return null;
+		return entry.data;
+	} catch {
+		return null;
+	}
+}
+function setCache(key, data, ttlMs = DEFAULT_TTL_MS) {
+	ensureCacheDir();
+	const cachePath = getCachePath(key);
+	const entry = {
+		data,
+		timestamp: Date.now(),
+		ttl: ttlMs
+	};
+	writeFileSync(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+}
+async function fetchWithCache(key, fetcher, ttlMs = DEFAULT_TTL_MS) {
+	const cached = getCached(key);
+	if (cached !== null) return cached;
+	const data = await fetcher();
+	setCache(key, data, ttlMs);
+	return data;
+}
+
 //#endregion
 //#region src/api/fetch.ts
 const GITHUB_RAW_BASE = "https://raw.githubusercontent.com/TanStack/cli/main/integrations";
+const CACHE_TTL_MS = 3600 * 1e3;
 /**
 * Check if a path is a local directory
 */
@@ -1976,36 +2019,40 @@ function isLocalPath(path) {
 	return path.startsWith("/") || path.startsWith("./") || path.startsWith("..");
 }
 /**
-* Fetch the integration manifest from GitHub or local path
+* Fetch the integration manifest from GitHub or local path (with caching for remote)
 */
 async function fetchManifest(baseUrl = GITHUB_RAW_BASE) {
 	if (isLocalPath(baseUrl)) {
 		const manifestPath = join(baseUrl, "manifest.json");
 		if (!existsSync(manifestPath)) throw new Error(`Manifest not found at ${manifestPath}`);
-		const data$1 = JSON.parse(readFileSync(manifestPath, "utf-8"));
-		return ManifestSchema.parse(data$1);
+		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);
+	return fetchWithCache(`manifest_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		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);
+	}, CACHE_TTL_MS);
 }
 /**
-* Fetch integration info.json from GitHub or local path
+* Fetch integration info.json from GitHub or local path (with caching for remote)
 */
 async function fetchIntegrationInfo(integrationId, baseUrl = GITHUB_RAW_BASE) {
 	if (isLocalPath(baseUrl)) {
 		const infoPath = join(baseUrl, integrationId, "info.json");
 		if (!existsSync(infoPath)) throw new Error(`Integration info not found at ${infoPath}`);
-		const data$1 = JSON.parse(readFileSync(infoPath, "utf-8"));
-		return IntegrationInfoSchema.parse(data$1);
+		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);
+	return fetchWithCache(`integration_info_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		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);
+	}, CACHE_TTL_MS);
 }
 /**
 * Recursively read all files from a directory
@@ -2022,21 +2069,23 @@ function readDirRecursive(dir, basePath = "") {
 	return files;
 }
 /**
-* Fetch all files for an integration from GitHub or local path
+* Fetch all files for an integration from GitHub or local path (with caching for remote)
 */
 async function fetchIntegrationFiles(integrationId, baseUrl = GITHUB_RAW_BASE) {
 	if (isLocalPath(baseUrl)) return readDirRecursive(join(baseUrl, integrationId, "assets"));
-	const filesUrl = `${baseUrl}/${integrationId}/files.json`;
-	const response = await fetch(filesUrl);
-	if (!response.ok) return {};
-	const fileList = await response.json();
-	const files = {};
-	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;
+	return fetchWithCache(`integration_files_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		const filesUrl = `${baseUrl}/${integrationId}/files.json`;
+		const response = await fetch(filesUrl);
+		if (!response.ok) return {};
+		const fileList = await response.json();
+		const files = {};
+		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;
+	}, CACHE_TTL_MS);
 }
 /**
 * Fetch integration package.json if it exists

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "TanStack CLI for scaffolding and tooling",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/api/fetch.test.ts

@@ -1,11 +1,11 @@
 import { resolve } from 'node:path'
 import { describe, expect, it } from 'vitest'
 import {
-  fetchManifest,
   fetchIntegration,
-  fetchIntegrations,
-  fetchIntegrationInfo,
   fetchIntegrationFiles,
+  fetchIntegrationInfo,
+  fetchIntegrations,
+  fetchManifest,
 } from './fetch.js'
 
 const INTEGRATIONS_PATH = resolve(__dirname, '../../../../integrations')

package/src/api/fetch.ts

@@ -5,11 +5,15 @@ import {
   IntegrationInfoSchema,
   ManifestSchema
 } from '../engine/types.js'
+import { fetchWithCache } from '../cache/index.js'
 import type { IntegrationCompiled, IntegrationInfo, Manifest } from '../engine/types.js'
 
 const GITHUB_RAW_BASE =
   'https://raw.githubusercontent.com/TanStack/cli/main/integrations'
 
+// 1 hour cache TTL for remote fetches
+const CACHE_TTL_MS = 60 * 60 * 1000
+
 /**
  * Check if a path is a local directory
  */
@@ -18,7 +22,7 @@ function isLocalPath(path: string): boolean {
 }
 
 /**
- * Fetch the integration manifest from GitHub or local path
+ * Fetch the integration manifest from GitHub or local path (with caching for remote)
  */
 export async function fetchManifest(
   baseUrl: string = GITHUB_RAW_BASE,
@@ -32,19 +36,27 @@ export async function fetchManifest(
     return ManifestSchema.parse(data)
   }
 
-  const url = `${baseUrl}/manifest.json`
-  const response = await fetch(url)
+  const cacheKey = `manifest_${baseUrl.replace(/[^a-zA-Z0-9]/g, '_')}`
 
-  if (!response.ok) {
-    throw new Error(`Failed to fetch manifest: ${response.statusText}`)
-  }
+  return fetchWithCache(
+    cacheKey,
+    async () => {
+      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)
+      const data = await response.json()
+      return ManifestSchema.parse(data)
+    },
+    CACHE_TTL_MS,
+  )
 }
 
 /**
- * Fetch integration info.json from GitHub or local path
+ * Fetch integration info.json from GitHub or local path (with caching for remote)
  */
 export async function fetchIntegrationInfo(
   integrationId: string,
@@ -59,15 +71,23 @@ export async function fetchIntegrationInfo(
     return IntegrationInfoSchema.parse(data)
   }
 
-  const url = `${baseUrl}/${integrationId}/info.json`
-  const response = await fetch(url)
+  const cacheKey = `integration_info_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, '_')}`
 
-  if (!response.ok) {
-    throw new Error(`Failed to fetch integration ${integrationId}: ${response.statusText}`)
-  }
+  return fetchWithCache(
+    cacheKey,
+    async () => {
+      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)
+      const data = await response.json()
+      return IntegrationInfoSchema.parse(data)
+    },
+    CACHE_TTL_MS,
+  )
 }
 
 /**
@@ -97,7 +117,7 @@ function readDirRecursive(
 }
 
 /**
- * Fetch all files for an integration from GitHub or local path
+ * Fetch all files for an integration from GitHub or local path (with caching for remote)
  */
 export async function fetchIntegrationFiles(
   integrationId: string,
@@ -108,31 +128,39 @@ export async function fetchIntegrationFiles(
     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)
+  const cacheKey = `integration_files_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, '_')}`
 
-  if (!response.ok) {
-    // No files.json, return empty
-    return {}
-  }
+  return fetchWithCache(
+    cacheKey,
+    async () => {
+      // First fetch the file list (we'll need a files.json or similar)
+      const filesUrl = `${baseUrl}/${integrationId}/files.json`
+      const response = await fetch(filesUrl)
 
-  const fileList: Array<string> = await response.json()
-  const files: Record<string, string> = {}
+      if (!response.ok) {
+        // No files.json, return empty
+        return {}
+      }
 
-  // Fetch each file
-  await Promise.all(
-    fileList.map(async (filePath) => {
-      const fileUrl = `${baseUrl}/${integrationId}/assets/${filePath}`
-      const fileResponse = await fetch(fileUrl)
+      const fileList: Array<string> = await response.json()
+      const files: Record<string, string> = {}
 
-      if (fileResponse.ok) {
-        files[filePath] = await fileResponse.text()
-      }
-    }),
-  )
+      // Fetch each file
+      await Promise.all(
+        fileList.map(async (filePath) => {
+          const fileUrl = `${baseUrl}/${integrationId}/assets/${filePath}`
+          const fileResponse = await fetch(fileUrl)
 
-  return files
+          if (fileResponse.ok) {
+            files[filePath] = await fileResponse.text()
+          }
+        }),
+      )
+
+      return files
+    },
+    CACHE_TTL_MS,
+  )
 }
 
 /**

package/src/cache/index.ts

@@ -0,0 +1,89 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const CACHE_DIR = join(homedir(), '.tanstack', 'cache')
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000 // 24 hours
+
+interface CacheEntry<T> {
+  data: T
+  timestamp: number
+  ttl: number
+}
+
+function ensureCacheDir() {
+  if (!existsSync(CACHE_DIR)) {
+    mkdirSync(CACHE_DIR, { recursive: true })
+  }
+}
+
+function getCachePath(key: string): string {
+  // Sanitize key to be filesystem-safe
+  const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, '_')
+  return join(CACHE_DIR, `${safeKey}.json`)
+}
+
+export function getCached<T>(key: string): T | null {
+  const cachePath = getCachePath(key)
+  
+  if (!existsSync(cachePath)) {
+    return null
+  }
+
+  try {
+    const raw = readFileSync(cachePath, 'utf-8')
+    const entry: CacheEntry<T> = JSON.parse(raw)
+    
+    const age = Date.now() - entry.timestamp
+    if (age > entry.ttl) {
+      return null // Expired
+    }
+    
+    return entry.data
+  } catch {
+    return null
+  }
+}
+
+export function setCache<T>(key: string, data: T, ttlMs: number = DEFAULT_TTL_MS): void {
+  ensureCacheDir()
+  const cachePath = getCachePath(key)
+  
+  const entry: CacheEntry<T> = {
+    data,
+    timestamp: Date.now(),
+    ttl: ttlMs,
+  }
+  
+  writeFileSync(cachePath, JSON.stringify(entry, null, 2), 'utf-8')
+}
+
+export async function fetchWithCache<T>(
+  key: string,
+  fetcher: () => Promise<T>,
+  ttlMs: number = DEFAULT_TTL_MS,
+): Promise<T> {
+  // Try cache first
+  const cached = getCached<T>(key)
+  if (cached !== null) {
+    return cached
+  }
+  
+  // Fetch fresh data
+  const data = await fetcher()
+  
+  // Cache it
+  setCache(key, data, ttlMs)
+  
+  return data
+}
+
+export function clearCache(): void {
+  if (existsSync(CACHE_DIR)) {
+    rmSync(CACHE_DIR, { recursive: true, force: true })
+  }
+}
+
+export function getCacheDir(): string {
+  return CACHE_DIR
+}

package/src/commands/create.ts

@@ -19,8 +19,8 @@ import { compile } from '../engine/compile.js'
 import { writeConfigFile } from '../engine/config-file.js'
 import { loadTemplate } from '../engine/custom-addons/template.js'
 import type {
-  IntegrationCompiled,
   CustomTemplateCompiled,
+  IntegrationCompiled,
   ManifestIntegration,
   PackageManager,
   RouterMode,

package/src/commands/mcp.test.ts

@@ -32,7 +32,7 @@ describe('MCP server tools logic', () => {
           description: integration.description,
           category: integration.category,
           dependsOn: integration.dependsOn,
-          conflicts: integration.conflicts,
+          exclusive: integration.exclusive,
           hasOptions: integration.hasOptions,
         }))
 
@@ -44,7 +44,7 @@ describe('MCP server tools logic', () => {
       expect(query!.category).toBe('tanstack')
     })
 
-    it('should include dependency and conflict info', async () => {
+    it('should include dependency and exclusive type info', async () => {
       const manifest = await fetchManifest(INTEGRATIONS_PATH)
       const integrations = manifest.integrations.filter((a) =>
         a.modes.includes('file-router'),
@@ -54,7 +54,7 @@ describe('MCP server tools logic', () => {
       expect(trpc?.dependsOn).toContain('tanstack-query')
 
       const clerk = integrations.find((i) => i.id === 'clerk')
-      expect(clerk?.conflicts).toContain('better-auth')
+      expect(clerk?.exclusive).toContain('auth')
     })
   })
 

package/src/commands/mcp.ts

@@ -5,6 +5,7 @@ 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 {
@@ -33,7 +34,7 @@ function createServer() {
             description: integration.description,
             category: integration.category,
             dependsOn: integration.dependsOn,
-            conflicts: integration.conflicts,
+            exclusive: integration.exclusive,
             hasOptions: integration.hasOptions,
           }))
 
@@ -58,6 +59,9 @@ function createServer() {
     },
   )
 
+  // Register documentation/ecosystem tools
+  registerDocTools(server)
+
   server.tool(
     'createTanStackApplication',
     'Create a new TanStack Start application',

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

@@ -2,7 +2,7 @@ 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 { IntegrationCompiled, CompileOptions } from './types.js'
+import type { CompileOptions, IntegrationCompiled } from './types.js'
 
 const INTEGRATIONS_PATH = resolve(__dirname, '../../../../integrations')
 
@@ -214,16 +214,16 @@ describe('compile with real integrations', () => {
     })
   })
 
-  describe('Deployment integration (Vercel)', () => {
-    let vercelIntegration: IntegrationCompiled
+  describe('Deployment integration (Railway)', () => {
+    let railwayIntegration: IntegrationCompiled
 
     beforeAll(async () => {
-      vercelIntegration = await fetchIntegration('vercel', INTEGRATIONS_PATH)
+      railwayIntegration = await fetchIntegration('railway', INTEGRATIONS_PATH)
     })
 
-    it('should load vercel integration', () => {
-      expect(vercelIntegration.id).toBe('vercel')
-      expect(vercelIntegration.type).toBe('deployment')
+    it('should load railway integration', () => {
+      expect(railwayIntegration.id).toBe('railway')
+      expect(railwayIntegration.type).toBe('deployment')
     })
   })
 })

package/src/engine/compile.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { compile, compileWithAttribution } from './compile.js'
-import type { IntegrationCompiled, CompileOptions, CustomTemplateCompiled } from './types.js'
+import type { CompileOptions, CustomTemplateCompiled, IntegrationCompiled } from './types.js'
 
 const baseOptions: CompileOptions = {
   projectName: 'test-project',

package/src/engine/compile.ts

@@ -1,12 +1,12 @@
 import { getBaseFiles, getBaseFilesWithAttribution } from '../templates/base.js'
 import { processTemplateFile } from './template.js'
 import type {
-  IntegrationCompiled,
-  IntegrationPhase,
   AttributedCompileOutput,
   CompileOptions,
   CompileOutput,
   EnvVar,
+  IntegrationCompiled,
+  IntegrationPhase,
   LineAttribution,
 } from './types.js'
 
@@ -130,8 +130,8 @@ function buildPackageJson(
       '@tanstack/react-router': '^1.132.0',
       '@tanstack/react-router-devtools': '^1.132.0',
       '@tanstack/react-start': '^1.132.0',
-      react: '^19.0.0',
-      'react-dom': '^19.0.0',
+      react: '^19.2.0',
+      'react-dom': '^19.2.0',
       'vite-tsconfig-paths': '^5.1.4',
       ...(hasHeader ? { 'lucide-react': '^0.468.0' } : {}),
       ...packages.dependencies,
@@ -141,8 +141,8 @@ function buildPackageJson(
       vite: '^7.0.0',
       ...(options.typescript
         ? {
-            '@types/react': '^19.0.0',
-            '@types/react-dom': '^19.0.0',
+            '@types/react': '^19.2.0',
+            '@types/react-dom': '^19.2.0',
             typescript: '^5.7.0',
           }
         : {}),

package/src/engine/custom-addons/shared.ts

@@ -13,7 +13,7 @@ import { readConfigFile } from '../config-file.js'
 import { fetchIntegrations } from '../../api/fetch.js'
 
 import type { PersistedOptions } from '../config-file.js'
-import type { IntegrationCompiled, CompileOptions, CompileOutput } from '../types.js'
+import type { CompileOptions, CompileOutput, IntegrationCompiled } from '../types.js'
 
 // Files to always ignore (from Jack's IGNORE_FILES)
 const IGNORE_FILES = [

package/src/engine/template.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest'
 import {
-  relativePath,
   createTemplateContext,
   processTemplateFile,
+  relativePath,
 } from './template.js'
 import type { CompileOptions } from './types.js'
 

package/src/engine/template.ts

@@ -1,8 +1,8 @@
 import { render } from 'ejs'
 import type {
-  IntegrationCompiled,
   CompileOptions,
   Hook,
+  IntegrationCompiled,
   Route,
 } from './types.js'