@tanstack/cli 0.60.1 → 0.62.0

package/dist/mcp/api.js

@@ -1,31 +0,0 @@
-import { LibrariesResponseSchema, PartnersResponseSchema } from './types.js';
-const TANSTACK_API_BASE = 'https://tanstack.com/api/data';
-export async function fetchLibraries() {
-    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() {
-    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, branch, filePath) {
-    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/dist/mcp/tools.js

@@ -1,250 +0,0 @@
-import { z } from 'zod';
-import { fetchDocContent, fetchLibraries, fetchPartners } from './api.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'];
-function jsonResult(data) {
-    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-}
-function errorResult(error) {
-    return { content: [{ type: 'text', text: `Error: ${error}` }], isError: true };
-}
-export function registerDocTools(server) {
-    // 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 = ['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();
-            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) => 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 = {
-                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;
-            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/dist/mcp/types.js

@@ -1,37 +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()),
-});

package/dist/mcp.js

@@ -1,181 +0,0 @@
-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 = [], }) {
-    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,
-                        type: addOn.type,
-                        category: addOn.category,
-                        link: addOn.link,
-                        warning: addOn.warning,
-                        exclusive: addOn.exclusive,
-                        options: addOn.options,
-                        dependsOn: addOn.dependsOn,
-                    }))),
-                },
-            ],
-        };
-    });
-    server.tool('getAddOnDetails', 'Get detailed information about a specific add-on including implementation patterns, routes, dependencies, and documentation', {
-        framework: z
-            .string()
-            .describe(`The framework to use. Available frameworks: ${frameworkNames.join(', ')}`),
-        addOnId: z
-            .string()
-            .describe('The ID of the add-on to get details for'),
-    }, async ({ framework: frameworkName, addOnId }) => {
-        const framework = getFrameworkByName(frameworkName);
-        const allAddOns = framework.getAddOns();
-        const addOn = allAddOns.find((a) => a.id === addOnId) ??
-            allAddOns.find((a) => a.id.toLowerCase() === addOnId.toLowerCase());
-        if (!addOn) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ error: `Add-on '${addOnId}' not found` }),
-                    },
-                ],
-            };
-        }
-        // Get file list for context
-        const files = await addOn.getFiles();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        id: addOn.id,
-                        name: addOn.name,
-                        description: addOn.description,
-                        type: addOn.type,
-                        category: addOn.category,
-                        phase: addOn.phase,
-                        modes: addOn.modes,
-                        link: addOn.link,
-                        warning: addOn.warning,
-                        exclusive: addOn.exclusive,
-                        dependsOn: addOn.dependsOn,
-                        options: addOn.options,
-                        routes: addOn.routes,
-                        packageAdditions: addOn.packageAdditions,
-                        shadcnComponents: addOn.shadcnComponents,
-                        integrations: addOn.integrations,
-                        readme: addOn.readme,
-                        files,
-                        author: addOn.author,
-                        version: addOn.version,
-                        license: addOn.license,
-                    }),
-                },
-            ],
-        };
-    });
-    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,
-                    ...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, { forcedAddOns, appName, name, }) {
-    let transport = 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);
-    }
-}

package/dist/types/mcp/api.d.ts

@@ -1,4 +0,0 @@
-import type { LibrariesResponse, PartnersResponse } from './types.js';
-export declare function fetchLibraries(): Promise<LibrariesResponse>;
-export declare function fetchPartners(): Promise<PartnersResponse>;
-export declare function fetchDocContent(repo: string, branch: string, filePath: string): Promise<string | null>;

package/dist/types/mcp/tools.d.ts

@@ -1,2 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function registerDocTools(server: McpServer): void;

package/dist/types/mcp.d.ts

@@ -1,5 +0,0 @@
-export declare function runMCPServer(sse: boolean, { forcedAddOns, appName, name, }: {
-    forcedAddOns?: Array<string>;
-    appName?: string;
-    name?: string;
-}): Promise<void>;