@tanstack/cli 0.0.8 → 0.48.2

package/dist/mcp/tools.js

@@ -0,0 +1,250 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,121 @@
+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,
+                        options: addOn.options,
+                        dependsOn: addOn.dependsOn,
+                    }))),
+                },
+            ],
+        };
+    });
+    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/options.js

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import { cancel, confirm, intro, isCancel } from '@clack/prompts';
+import { finalizeAddOns, getFrameworkById, getPackageManager, populateAddOnOptionsDefaults, readConfigFile, } from '@tanstack/create';
+import { getProjectName, promptForAddOnOptions, selectAddOns, selectDeployment, selectGit, selectPackageManager, selectRouterType, selectTailwind, selectToolchain, selectTypescript, } from './ui-prompts.js';
+import { getCurrentDirectoryName, sanitizePackageName, validateProjectName, } from './utils.js';
+export async function promptForCreateOptions(cliOptions, { forcedAddOns = [], forcedMode, showDeploymentOptions = false, }) {
+    const options = {};
+    options.framework = getFrameworkById(cliOptions.framework || 'react-cra');
+    // Validate project name
+    if (cliOptions.projectName) {
+        // Handle "." as project name - use sanitized current directory name
+        if (cliOptions.projectName === '.') {
+            options.projectName = sanitizePackageName(getCurrentDirectoryName());
+        }
+        else {
+            options.projectName = cliOptions.projectName;
+        }
+        const { valid, error } = validateProjectName(options.projectName);
+        if (!valid) {
+            console.error(error);
+            process.exit(1);
+        }
+    }
+    else {
+        options.projectName = await getProjectName();
+    }
+    // Check if target directory is empty
+    if (!cliOptions.force &&
+        fs.existsSync(options.projectName) &&
+        fs.readdirSync(options.projectName).length > 0) {
+        const shouldContinue = await confirm({
+            message: `Target directory ${options.projectName} is not empty. Do you want to continue?`,
+            initialValue: true,
+        });
+        if (isCancel(shouldContinue) || !shouldContinue) {
+            cancel('Operation cancelled.');
+            process.exit(0);
+        }
+    }
+    // Router type selection
+    if (forcedMode) {
+        options.mode = forcedMode;
+    }
+    else if (cliOptions.template) {
+        options.mode =
+            cliOptions.template === 'file-router' ? 'file-router' : 'code-router';
+    }
+    else {
+        options.mode = await selectRouterType();
+    }
+    // TypeScript selection (if using Code Router)
+    // TODO: Make this declarative
+    options.typescript =
+        options.mode === 'file-router' || options.framework.id === 'solid';
+    if (forcedMode &&
+        options.framework.supportedModes[forcedMode].forceTypescript) {
+        options.typescript = true;
+    }
+    if (!options.typescript && options.mode === 'code-router') {
+        options.typescript = await selectTypescript();
+    }
+    // Package manager selection
+    if (cliOptions.packageManager) {
+        options.packageManager = cliOptions.packageManager;
+    }
+    else {
+        const detectedPackageManager = await getPackageManager();
+        options.packageManager =
+            detectedPackageManager || (await selectPackageManager());
+    }
+    // Toolchain selection
+    const toolchain = await selectToolchain(options.framework, cliOptions.toolchain);
+    // Deployment selection
+    const deployment = showDeploymentOptions
+        ? await selectDeployment(options.framework, cliOptions.deployment)
+        : undefined;
+    // Add-ons selection
+    const addOns = new Set();
+    if (toolchain) {
+        addOns.add(toolchain);
+    }
+    if (deployment) {
+        addOns.add(deployment);
+    }
+    for (const addOn of forcedAddOns) {
+        addOns.add(addOn);
+    }
+    if (Array.isArray(cliOptions.addOns)) {
+        for (const addOn of cliOptions.addOns) {
+            addOns.add(addOn);
+        }
+    }
+    else {
+        for (const addOn of await selectAddOns(options.framework, options.mode, 'add-on', 'What add-ons would you like for your project?', forcedAddOns)) {
+            addOns.add(addOn);
+        }
+        for (const addOn of await selectAddOns(options.framework, options.mode, 'example', 'Would you like an example?', forcedAddOns, false)) {
+            addOns.add(addOn);
+        }
+    }
+    options.chosenAddOns = Array.from(await finalizeAddOns(options.framework, options.mode, Array.from(addOns)));
+    if (options.chosenAddOns.length) {
+        options.typescript = true;
+    }
+    // Tailwind selection
+    // Only treat add-ons as requiring tailwind if they explicitly have "tailwind": true
+    const addOnsRequireTailwind = options.chosenAddOns.some((addOn) => addOn.tailwind === true);
+    if (addOnsRequireTailwind) {
+        // If any add-on explicitly requires tailwind, enable it automatically
+        options.tailwind = true;
+    }
+    else if (cliOptions.tailwind !== undefined) {
+        // User explicitly provided a CLI flag, respect it
+        options.tailwind = !!cliOptions.tailwind;
+    }
+    else if (options.framework.id === 'react-cra') {
+        // Only show prompt for react-cra when no CLI flag and no add-ons require it
+        options.tailwind = await selectTailwind();
+    }
+    else {
+        // For other frameworks (like solid), default to true
+        options.tailwind = true;
+    }
+    // Prompt for add-on options in interactive mode
+    if (Array.isArray(cliOptions.addOns)) {
+        // Non-interactive mode: use defaults
+        options.addOnOptions = populateAddOnOptionsDefaults(options.chosenAddOns);
+    }
+    else {
+        // Interactive mode: prompt for options
+        const userOptions = await promptForAddOnOptions(options.chosenAddOns.map((a) => a.id), options.framework);
+        const defaultOptions = populateAddOnOptionsDefaults(options.chosenAddOns);
+        // Merge user options with defaults
+        options.addOnOptions = { ...defaultOptions, ...userOptions };
+    }
+    options.git = cliOptions.git || (await selectGit());
+    if (cliOptions.install === false) {
+        options.install = false;
+    }
+    return options;
+}
+export async function promptForAddOns() {
+    const config = await readConfigFile(process.cwd());
+    if (!config) {
+        console.error('No config file found');
+        process.exit(1);
+    }
+    const framework = getFrameworkById(config.framework);
+    if (!framework) {
+        console.error(`Unknown framework: ${config.framework}`);
+        process.exit(1);
+    }
+    intro(`Adding new add-ons to '${config.projectName}'`);
+    const addOns = new Set();
+    for (const addOn of await selectAddOns(framework, config.mode, 'add-on', 'What add-ons would you like for your project?', config.chosenAddOns)) {
+        addOns.add(addOn);
+    }
+    for (const addOn of await selectAddOns(framework, config.mode, 'example', 'Would you like any examples?', config.chosenAddOns)) {
+        addOns.add(addOn);
+    }
+    return Array.from(addOns);
+}

package/dist/types/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/cli.d.ts

@@ -0,0 +1,16 @@
+import type { TemplateOptions } from './types.js';
+import type { FrameworkDefinition } from '@tanstack/create';
+export declare function cli({ name, appName, forcedMode, forcedAddOns, defaultTemplate, forcedDeployment, defaultFramework, craCompatible, webBase, frameworkDefinitionInitializers, showDeploymentOptions, legacyAutoCreate, }: {
+    name: string;
+    appName: string;
+    forcedMode?: string;
+    forcedAddOns?: Array<string>;
+    forcedDeployment?: string;
+    defaultTemplate?: TemplateOptions;
+    defaultFramework?: string;
+    craCompatible?: boolean;
+    webBase?: string;
+    frameworkDefinitionInitializers?: Array<() => FrameworkDefinition>;
+    showDeploymentOptions?: boolean;
+    legacyAutoCreate?: boolean;
+}): void;

package/dist/types/command-line.d.ts

@@ -0,0 +1,10 @@
+import type { Options } from '@tanstack/create';
+import type { CliOptions } from './types.js';
+export declare function normalizeOptions(cliOptions: CliOptions, forcedMode?: string, forcedAddOns?: Array<string>, opts?: {
+    disableNameCheck?: boolean;
+    forcedDeployment?: string;
+}): Promise<Options | undefined>;
+export declare function validateDevWatchOptions(cliOptions: CliOptions): {
+    valid: boolean;
+    error?: string;
+};

package/dist/types/dev-watch.d.ts

@@ -0,0 +1,27 @@
+import type { Environment, Framework, FrameworkDefinition, Options } from '@tanstack/create';
+export interface DevWatchOptions {
+    watchPath: string;
+    targetDir: string;
+    framework: Framework;
+    cliOptions: Options;
+    packageManager: string;
+    environment: Environment;
+    frameworkDefinitionInitializers?: Array<() => FrameworkDefinition>;
+}
+export declare class DevWatchManager {
+    private options;
+    private watcher;
+    private debounceQueue;
+    private syncer;
+    private tempDir;
+    private isBuilding;
+    private buildCount;
+    constructor(options: DevWatchOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private startWatcher;
+    private handleChange;
+    private rebuild;
+    private cleanup;
+    private log;
+}

package/dist/types/file-syncer.d.ts

@@ -0,0 +1,18 @@
+export interface FileUpdate {
+    path: string;
+    diff?: string;
+}
+export interface SyncResult {
+    updated: Array<FileUpdate>;
+    skipped: Array<string>;
+    created: Array<string>;
+    errors: Array<string>;
+}
+export declare class FileSyncer {
+    sync(sourceDir: string, targetDir: string): Promise<SyncResult>;
+    private syncDirectory;
+    private shouldUpdateFile;
+    private calculateHash;
+    private shouldSkipDirectory;
+    private shouldSkipFile;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { cli } from './cli.js';

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

@@ -0,0 +1,4 @@
+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

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