@tanstack/cta-cli 0.46.2 → 0.47.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @tanstack/cta-cli
+
+## 0.47.0
+
+### Minor Changes
+
+- Smakll content fixes ([`7647683`](https://github.com/TanStack/create-tsrouter-app/commit/76476838fc427d71535881b959530307ca4664a2))
+
+- allowing for no tailwind ([#151](https://github.com/TanStack/create-tsrouter-app/pull/151))
+
+### Patch Changes
+
+- Updated dependencies [[`7647683`](https://github.com/TanStack/create-tsrouter-app/commit/76476838fc427d71535881b959530307ca4664a2), [`f1f58fe`](https://github.com/TanStack/create-tsrouter-app/commit/f1f58feed7d7df1e0c5e0fc4dd3af02e11df09e5)]:
+  - @tanstack/cta-engine@0.47.0
+  - @tanstack/cta-ui@0.47.0

package/dist/cli.js

@@ -8,11 +8,12 @@ import { SUPPORTED_PACKAGE_MANAGERS, addToApp, compileAddOn, compileStarter, cre
 import { launchUI } from '@tanstack/cta-ui';
 import { runMCPServer } from './mcp.js';
 import { promptForAddOns, promptForCreateOptions } from './options.js';
-import { normalizeOptions } from './command-line.js';
+import { normalizeOptions, validateDevWatchOptions } from './command-line.js';
 import { createUIEnvironment } from './ui-environment.js';
 import { convertTemplateToMode } from './utils.js';
+import { DevWatchManager } from './dev-watch.js';
 // This CLI assumes that all of the registered frameworks have the same set of toolchains, deployments, modes, etc.
-export function cli({ name, appName, forcedMode, forcedAddOns = [], defaultTemplate = 'javascript', forcedDeployment, defaultFramework, craCompatible = false, webBase, showDeploymentOptions = false, }) {
+export function cli({ name, appName, forcedMode, forcedAddOns = [], defaultTemplate = 'javascript', forcedDeployment, defaultFramework, craCompatible = false, webBase, frameworkDefinitionInitializers, showDeploymentOptions = false, }) {
     const environment = createUIEnvironment(appName, false);
     const program = new Command();
     const availableFrameworks = getFrameworks().map((f) => f.name);
@@ -194,12 +195,14 @@ Remove your node_modules directory and package lock file and re-install.`);
     }
     program
         .option('--starter [url]', 'initialize this project from a starter URL', false)
+        .option('--no-install', 'skip installing dependencies')
         .option(`--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`, `Explicitly tell the CLI to use this package manager`, (value) => {
         if (!SUPPORTED_PACKAGE_MANAGERS.includes(value)) {
             throw new InvalidArgumentError(`Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
         }
         return value;
-    });
+    })
+        .option('--dev-watch <path>', 'Watch a framework directory for changes and auto-rebuild');
     if (deployments.size > 0) {
         program.option(`--deployment <${Array.from(deployments).join('|')}>`, `Explicitly tell the CLI to use this deployment adapter`, (value) => {
             if (!deployments.has(value)) {
@@ -218,7 +221,8 @@ Remove your node_modules directory and package lock file and re-install.`);
     }
     program
         .option('--interactive', 'interactive mode', false)
-        .option('--tailwind', 'add Tailwind CSS', false)
+        .option('--tailwind', 'add Tailwind CSS')
+        .option('--no-tailwind', 'skip Tailwind CSS')
         .option('--add-ons [...add-ons]', 'pick from a list of available add-ons (comma separated list)', (value) => {
         let addOns = !!value;
         if (typeof value === 'string') {
@@ -309,6 +313,59 @@ Remove your node_modules directory and package lock file and re-install.`);
                 appName,
             });
         }
+        else if (options.devWatch) {
+            // Validate dev watch options
+            const validation = validateDevWatchOptions({ ...options, projectName });
+            if (!validation.valid) {
+                console.error(validation.error);
+                process.exit(1);
+            }
+            // Enter dev watch mode
+            if (!projectName && !options.targetDir) {
+                console.error('Project name/target directory is required for dev watch mode');
+                process.exit(1);
+            }
+            if (!options.framework) {
+                console.error('Failed to detect framework');
+                process.exit(1);
+            }
+            const framework = getFrameworkByName(options.framework);
+            if (!framework) {
+                console.error('Failed to detect framework');
+                process.exit(1);
+            }
+            // First, create the app normally using the standard flow
+            const normalizedOpts = await normalizeOptions({
+                ...options,
+                projectName,
+                framework: framework.id,
+            }, defaultMode, forcedAddOns);
+            if (!normalizedOpts) {
+                throw new Error('Failed to normalize options');
+            }
+            normalizedOpts.targetDir =
+                options.targetDir || resolve(process.cwd(), projectName);
+            // Create the initial app with minimal output for dev watch mode
+            console.log(chalk.bold('\ndev-watch'));
+            console.log(chalk.gray('├─') + ' ' + `creating initial ${appName} app...`);
+            if (normalizedOpts.install !== false) {
+                console.log(chalk.gray('├─') + ' ' + chalk.yellow('⟳') + ' installing packages...');
+            }
+            const silentEnvironment = createUIEnvironment(appName, true);
+            await createApp(silentEnvironment, normalizedOpts);
+            console.log(chalk.gray('└─') + ' ' + chalk.green('✓') + ` app created`);
+            // Now start the dev watch mode
+            const manager = new DevWatchManager({
+                watchPath: options.devWatch,
+                targetDir: normalizedOpts.targetDir,
+                framework,
+                cliOptions: normalizedOpts,
+                packageManager: normalizedOpts.packageManager,
+                environment,
+                frameworkDefinitionInitializers,
+            });
+            await manager.start();
+        }
         else {
             try {
                 const cliOptions = {

package/dist/command-line.js

@@ -1,4 +1,5 @@
 import { resolve } from 'node:path';
+import fs from 'node:fs';
 import { DEFAULT_PACKAGE_MANAGER, finalizeAddOns, getFrameworkById, getPackageManager, loadStarter, populateAddOnOptionsDefaults, } from '@tanstack/cta-engine';
 import { getCurrentDirectoryName, sanitizePackageName, validateProjectName, } from './utils.js';
 export async function normalizeOptions(cliOptions, forcedMode, forcedAddOns, opts) {
@@ -83,8 +84,23 @@ export async function normalizeOptions(cliOptions, forcedMode, forcedAddOns, opt
     }
     const chosenAddOns = await selectAddOns();
     if (chosenAddOns.length) {
-        tailwind = true;
         typescript = true;
+        // Check if any add-on explicitly requires tailwind
+        const addOnsRequireTailwind = chosenAddOns.some((addOn) => addOn.tailwind === true);
+        // Only set tailwind to true if:
+        // 1. An add-on explicitly requires it, OR
+        // 2. User explicitly set it via CLI
+        if (addOnsRequireTailwind) {
+            tailwind = true;
+        }
+        else if (cliOptions.tailwind === true) {
+            tailwind = true;
+        }
+        else if (cliOptions.tailwind === false) {
+            tailwind = false;
+        }
+        // If cliOptions.tailwind is undefined and no add-ons require it,
+        // leave tailwind as is (will be prompted in interactive mode)
     }
     // Handle add-on configuration option
     let addOnOptionsFromCLI = {};
@@ -108,6 +124,7 @@ export async function normalizeOptions(cliOptions, forcedMode, forcedAddOns, opt
             getPackageManager() ||
             DEFAULT_PACKAGE_MANAGER,
         git: !!cliOptions.git,
+        install: cliOptions.install,
         chosenAddOns,
         addOnOptions: {
             ...populateAddOnOptionsDefaults(chosenAddOns),
@@ -116,3 +133,42 @@ export async function normalizeOptions(cliOptions, forcedMode, forcedAddOns, opt
         starter: starter,
     };
 }
+export function validateDevWatchOptions(cliOptions) {
+    if (!cliOptions.devWatch) {
+        return { valid: true };
+    }
+    // Validate watch path exists
+    const watchPath = resolve(process.cwd(), cliOptions.devWatch);
+    if (!fs.existsSync(watchPath)) {
+        return {
+            valid: false,
+            error: `Watch path does not exist: ${watchPath}`,
+        };
+    }
+    // Validate it's a directory
+    const stats = fs.statSync(watchPath);
+    if (!stats.isDirectory()) {
+        return {
+            valid: false,
+            error: `Watch path is not a directory: ${watchPath}`,
+        };
+    }
+    // Ensure target directory is specified
+    if (!cliOptions.projectName && !cliOptions.targetDir) {
+        return {
+            valid: false,
+            error: 'Project name or target directory is required for dev watch mode',
+        };
+    }
+    // Check for framework structure
+    const hasAddOns = fs.existsSync(resolve(watchPath, 'add-ons'));
+    const hasAssets = fs.existsSync(resolve(watchPath, 'assets'));
+    const hasFrameworkJson = fs.existsSync(resolve(watchPath, 'framework.json'));
+    if (!hasAddOns && !hasAssets && !hasFrameworkJson) {
+        return {
+            valid: false,
+            error: `Watch path does not appear to be a valid framework directory: ${watchPath}`,
+        };
+    }
+    return { valid: true };
+}

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/cta-engine';
+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/options.js

@@ -44,13 +44,6 @@ export async function promptForCreateOptions(cliOptions, { forcedAddOns = [], fo
     if (!options.typescript && options.mode === 'code-router') {
         options.typescript = await selectTypescript();
     }
-    // Tailwind selection
-    if (!cliOptions.tailwind && options.framework.id === 'react-cra') {
-        options.tailwind = await selectTailwind();
-    }
-    else {
-        options.tailwind = true;
-    }
     // Package manager selection
     if (cliOptions.packageManager) {
         options.packageManager = cliOptions.packageManager;
@@ -92,9 +85,27 @@ export async function promptForCreateOptions(cliOptions, { forcedAddOns = [], fo
     }
     options.chosenAddOns = Array.from(await finalizeAddOns(options.framework, options.mode, Array.from(addOns)));
     if (options.chosenAddOns.length) {
-        options.tailwind = true;
         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