@tanstack/cli 0.0.8 → 0.48.3

package/dist/dev-watch.js

@@ -0,0 +1,290 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import chalk from 'chalk';
+import { temporaryDirectory } from 'tempy';
+import { createApp, getFrameworkById, registerFramework, } from '@tanstack/create';
+import { FileSyncer } from './file-syncer.js';
+import { createUIEnvironment } from './ui-environment.js';
+class DebounceQueue {
+    constructor(callback, delay = 1000) {
+        this.delay = delay;
+        this.timer = null;
+        this.changes = new Set();
+        this.callback = callback;
+    }
+    add(path) {
+        this.changes.add(path);
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        this.timer = setTimeout(() => {
+            const currentChanges = new Set(this.changes);
+            this.callback(currentChanges);
+            this.changes.clear();
+        }, this.delay);
+    }
+    size() {
+        return this.changes.size;
+    }
+    clear() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.changes.clear();
+    }
+}
+export class DevWatchManager {
+    constructor(options) {
+        this.options = options;
+        this.watcher = null;
+        this.tempDir = null;
+        this.isBuilding = false;
+        this.buildCount = 0;
+        this.log = {
+            tree: (prefix, msg, isLast = false) => {
+                const connector = isLast ? '└─' : '├─';
+                console.log(chalk.gray(prefix + connector) + ' ' + msg);
+            },
+            treeItem: (prefix, msg, isLast = false) => {
+                const connector = isLast ? '└─' : '├─';
+                console.log(chalk.gray(prefix + '  ' + connector) + ' ' + msg);
+            },
+            info: (msg) => console.log(msg),
+            error: (msg) => console.error(chalk.red('✗') + ' ' + msg),
+            success: (msg) => console.log(chalk.green('✓') + ' ' + msg),
+            warning: (msg) => console.log(chalk.yellow('⚠') + ' ' + msg),
+            section: (title) => console.log('\n' + chalk.bold('▸ ' + title)),
+            subsection: (msg) => console.log('  ' + msg),
+        };
+        this.syncer = new FileSyncer();
+        this.debounceQueue = new DebounceQueue((changes) => this.rebuild(changes));
+    }
+    async start() {
+        // Validate watch path
+        if (!fs.existsSync(this.options.watchPath)) {
+            throw new Error(`Watch path does not exist: ${this.options.watchPath}`);
+        }
+        // Validate target directory exists (should have been created by createApp)
+        if (!fs.existsSync(this.options.targetDir)) {
+            throw new Error(`Target directory does not exist: ${this.options.targetDir}`);
+        }
+        if (this.options.cliOptions.install === false) {
+            throw new Error('Cannot use the --no-install flag when using --dev-watch');
+        }
+        // Log startup with tree style
+        console.log();
+        console.log(chalk.bold('dev-watch'));
+        this.log.tree('', `watching: ${chalk.cyan(this.options.watchPath)}`);
+        this.log.tree('', `target: ${chalk.cyan(this.options.targetDir)}`);
+        this.log.tree('', 'ready', true);
+        // Setup signal handlers
+        process.on('SIGINT', () => this.cleanup());
+        process.on('SIGTERM', () => this.cleanup());
+        // Start watching
+        this.startWatcher();
+    }
+    async stop() {
+        console.log();
+        this.log.info('Stopping dev watch mode...');
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        this.debounceQueue.clear();
+        this.cleanup();
+    }
+    startWatcher() {
+        const watcherConfig = {
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/dist/**',
+                '**/build/**',
+                '**/.DS_Store',
+                '**/*.log',
+                this.tempDir,
+            ],
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 100,
+            },
+        };
+        this.watcher = chokidar.watch(this.options.watchPath, watcherConfig);
+        this.watcher.on('add', (filePath) => this.handleChange('add', filePath));
+        this.watcher.on('change', (filePath) => this.handleChange('change', filePath));
+        this.watcher.on('unlink', (filePath) => this.handleChange('unlink', filePath));
+        this.watcher.on('error', (error) => this.log.error(`Watcher error: ${error.message}`));
+        this.watcher.on('ready', () => {
+            // Already shown in startup, no need to repeat
+        });
+    }
+    handleChange(_type, filePath) {
+        const relativePath = path.relative(this.options.watchPath, filePath);
+        // Log change only once for the first file in debounce queue
+        if (this.debounceQueue.size() === 0) {
+            this.log.section('change detected');
+            this.log.subsection(`└─ ${relativePath}`);
+        }
+        else {
+            this.log.subsection(`└─ ${relativePath}`);
+        }
+        this.debounceQueue.add(filePath);
+    }
+    async rebuild(changes) {
+        if (this.isBuilding) {
+            this.log.warning('Build already in progress, skipping...');
+            return;
+        }
+        this.isBuilding = true;
+        this.buildCount++;
+        const buildId = this.buildCount;
+        try {
+            this.log.section(`build #${buildId}`);
+            const startTime = Date.now();
+            if (!this.options.frameworkDefinitionInitializers) {
+                throw new Error('There must be framework initalizers passed to frameworkDefinitionInitializers to use --dev-watch');
+            }
+            const refreshedFrameworks = this.options.frameworkDefinitionInitializers.map((frameworkInitalizer) => frameworkInitalizer());
+            const refreshedFramework = refreshedFrameworks.find((f) => f.id === this.options.framework.id);
+            if (!refreshedFramework) {
+                throw new Error('Could not identify the framework');
+            }
+            // Update the chosen addons to use the latest code
+            const chosenAddonIds = this.options.cliOptions.chosenAddOns.map((m) => m.id);
+            const updatedChosenAddons = refreshedFramework.addOns.filter((f) => chosenAddonIds.includes(f.id));
+            // Create temp directory for this build using tempy
+            this.tempDir = temporaryDirectory();
+            // Register the scanned framework
+            registerFramework({
+                ...refreshedFramework,
+                id: `${refreshedFramework.id}-updated`,
+            });
+            // Get the registered framework
+            const registeredFramework = getFrameworkById(`${refreshedFramework.id}-updated`);
+            if (!registeredFramework) {
+                throw new Error(`Failed to register framework: ${this.options.framework.id}`);
+            }
+            // Check if package.json was modified
+            const packageJsonModified = Array.from(changes).some((filePath) => path.basename(filePath) === 'package.json');
+            const updatedOptions = {
+                ...this.options.cliOptions,
+                chosenAddOns: updatedChosenAddons,
+                framework: registeredFramework,
+                targetDir: this.tempDir,
+                git: false,
+                install: packageJsonModified,
+            };
+            // Show package installation indicator if needed
+            if (packageJsonModified) {
+                this.log.tree('  ', `${chalk.yellow('⟳')} installing packages...`);
+            }
+            // Create app in temp directory with silent environment
+            const silentEnvironment = createUIEnvironment(this.options.environment.appName, true);
+            await createApp(silentEnvironment, updatedOptions);
+            // Sync files to target directory
+            const syncResult = await this.syncer.sync(this.tempDir, this.options.targetDir);
+            // Clean up temp directory after sync is complete
+            try {
+                await fs.promises.rm(this.tempDir, { recursive: true, force: true });
+            }
+            catch (cleanupError) {
+                this.log.warning(`Failed to clean up temp directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+            const elapsed = Date.now() - startTime;
+            // Build tree-style summary
+            this.log.tree('  ', `duration: ${chalk.cyan(elapsed + 'ms')}`);
+            if (packageJsonModified) {
+                this.log.tree('  ', `packages: ${chalk.green('✓ installed')}`);
+            }
+            // Always show the last item in tree without checking for files to show
+            const noMoreTreeItems = syncResult.updated.length === 0 &&
+                syncResult.created.length === 0 &&
+                syncResult.errors.length === 0;
+            if (syncResult.updated.length > 0) {
+                this.log.tree('  ', `updated: ${chalk.green(syncResult.updated.length + ' file' + (syncResult.updated.length > 1 ? 's' : ''))}`, syncResult.created.length === 0 && syncResult.errors.length === 0);
+            }
+            if (syncResult.created.length > 0) {
+                this.log.tree('  ', `created: ${chalk.green(syncResult.created.length + ' file' + (syncResult.created.length > 1 ? 's' : ''))}`, syncResult.errors.length === 0);
+            }
+            if (syncResult.errors.length > 0) {
+                this.log.tree('  ', `failed: ${chalk.red(syncResult.errors.length + ' file' + (syncResult.errors.length > 1 ? 's' : ''))}`, true);
+            }
+            // If nothing changed, show that
+            if (noMoreTreeItems) {
+                this.log.tree('  ', `no changes`, true);
+            }
+            // Always show changed files with diffs
+            if (syncResult.updated.length > 0) {
+                syncResult.updated.forEach((update, index) => {
+                    const isLastFile = index === syncResult.updated.length - 1 &&
+                        syncResult.created.length === 0;
+                    // For files with diffs, always use ├─
+                    const fileIsLast = isLastFile && !update.diff;
+                    this.log.treeItem('  ', update.path, fileIsLast);
+                    // Always show diff if available
+                    if (update.diff) {
+                        const diffLines = update.diff.split('\n');
+                        const relevantLines = diffLines
+                            .slice(4)
+                            .filter((line) => line.startsWith('+') ||
+                            line.startsWith('-') ||
+                            line.startsWith('@'));
+                        if (relevantLines.length > 0) {
+                            // Always use │ to continue the tree line through the diff
+                            const prefix = '    │ ';
+                            relevantLines.forEach((line) => {
+                                if (line.startsWith('+') && !line.startsWith('+++')) {
+                                    console.log(chalk.gray(prefix) + '  ' + chalk.green(line));
+                                }
+                                else if (line.startsWith('-') && !line.startsWith('---')) {
+                                    console.log(chalk.gray(prefix) + '  ' + chalk.red(line));
+                                }
+                                else if (line.startsWith('@')) {
+                                    console.log(chalk.gray(prefix) + '  ' + chalk.cyan(line));
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+            // Show created files
+            if (syncResult.created.length > 0) {
+                syncResult.created.forEach((file, index) => {
+                    const isLast = index === syncResult.created.length - 1;
+                    this.log.treeItem('  ', `${chalk.green('+')} ${file}`, isLast);
+                });
+            }
+            // Always show errors
+            if (syncResult.errors.length > 0) {
+                console.log(); // Add spacing
+                syncResult.errors.forEach((err, index) => {
+                    this.log.tree('  ', `${chalk.red('error:')} ${err}`, index === syncResult.errors.length - 1);
+                });
+            }
+        }
+        catch (error) {
+            this.log.error(`Build #${buildId} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            this.isBuilding = false;
+        }
+    }
+    cleanup() {
+        console.log();
+        console.log('Cleaning up...');
+        // Clean up temp directory
+        if (this.tempDir && fs.existsSync(this.tempDir)) {
+            try {
+                fs.rmSync(this.tempDir, { recursive: true, force: true });
+            }
+            catch (error) {
+                this.log.error(`Failed to clean up temp directory: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        process.exit(0);
+    }
+}

package/dist/file-syncer.js

@@ -0,0 +1,148 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import * as diff from 'diff';
+export class FileSyncer {
+    async sync(sourceDir, targetDir) {
+        const result = {
+            updated: [],
+            skipped: [],
+            created: [],
+            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);
+        return result;
+    }
+    async syncDirectory(currentPath, targetBase, sourceBase, result) {
+        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;
+                }
+                try {
+                    const shouldUpdate = await this.shouldUpdateFile(sourcePath, targetPath);
+                    if (shouldUpdate) {
+                        // Check if file exists to generate diff
+                        let fileDiff;
+                        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)}`);
+                }
+            }
+        }
+    }
+    async shouldUpdateFile(sourcePath, targetPath) {
+        // 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;
+    }
+    async calculateHash(filePath) {
+        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);
+        });
+    }
+    shouldSkipDirectory(name) {
+        const skipDirs = [
+            'node_modules',
+            '.git',
+            'dist',
+            'build',
+            '.next',
+            '.nuxt',
+            '.cache',
+            '.tmp-dev',
+            'coverage',
+            '.turbo',
+        ];
+        return skipDirs.includes(name) || name.startsWith('.');
+    }
+    shouldSkipFile(name) {
+        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);
+    }
+}

package/dist/index.js

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

package/dist/mcp/api.js

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