create-react-adam 0.2.2 → 0.4.0

package/README.md

@@ -5,11 +5,23 @@ Create opinionated React apps with TypeScript, Vite, Wouter, and Tailwind CSS.
 ## Quick Start
 
 ```bash
-npx create-react-adam@latest my-app --with-e2e --with-utils
+npx create-react-adam@latest my-app --yes
 cd my-app
 npm run dev
 ```
 
+Running without flags opens an interactive wizard where you pick features
+(all pre-selected by default):
+
+```
+◆ Select features
+│ ◼ E2E testing (Playwright + Allure)
+│ ◼ Utility functions (classNames, Storage, useUrlState, safeTimeout)
+│ ◼ Lighthouse CI workflow (a11y/SEO/performance budgets)
+│ ◼ ESLint rule: prefer WebP images
+└
+```
+
 ## CLI Options
 
 - `--dir <path>` - Create the project in a specific directory
@@ -18,16 +30,21 @@ npm run dev
   npm create react-adam@latest my-app --dir ~/projects
   ```
 
-- `--with-e2e` - Include E2E testing setup without prompting
+- `--yes` - Skip the wizard and include every feature not explicitly disabled
+  by a flag. This is also the behavior when there is no TTY (CI, scripts, AI
+  agents), so the CLI never hangs waiting for input.
 
   ```bash
-  npm create react-adam@latest my-app --with-e2e
+  npm create react-adam@latest my-app --yes --no-e2e
   ```
 
-- `--no-e2e` - Skip E2E testing setup without prompting
-  ```bash
-  npm create react-adam@latest my-app --no-e2e
-  ```
+- `--with-e2e` / `--no-e2e` - Include or skip E2E testing (Playwright + Allure)
+- `--with-utils` / `--no-utils` - Include or skip utility functions
+- `--with-lighthouse` / `--no-lighthouse` - Include or skip the Lighthouse CI workflow
+- `--with-webp-lint` / `--no-webp-lint` - Include or skip the prefer-webp-images ESLint rule
+
+Any feature answered by a flag is removed from the wizard; if all four are
+answered, the wizard is skipped entirely.
 
 ## What's Included
 
@@ -39,6 +56,21 @@ npm run dev
 - **Tailwind CSS 4** - Utility-first CSS
 - **React Icons** - Popular icon library
 
+### Performance, SEO, and Accessibility Baseline
+
+Every generated project starts with:
+
+- **Self-hosted Inter font** - variable `woff2` served from `public/fonts/`
+  with `font-display: swap` and a preload hint; no third-party font requests
+- **Route-level code splitting with preloading** - pages load via
+  `React.lazy` + `Suspense`; chunks preload on link hover/focus/touch and an
+  idle prefetcher warms the rest after first paint (documented in the
+  generated README, easy to remove)
+- **SEO-ready `index.html`** - meta description, Open Graph and Twitter card
+  tags, theme-color, plus a `public/robots.txt`
+- **Accessible shell** - skip-to-content link, `<main>` landmark, visible
+  `:focus-visible` styles, and per-route document titles
+
 ### Code Quality Tools
 
 #### ESLint
@@ -50,8 +82,9 @@ Configured with a modern flat config (`eslint.config.js`) that includes:
 - **React Refresh** - Validates fast refresh compatibility
 - **JSX Accessibility** - Enforces accessibility best practices (a11y)
 - **Prettier integration** - Disables conflicting formatting rules
-
-Why ESLint? It catches bugs early, enforces consistent code patterns, and integrates seamlessly with TypeScript. The strict preset helps maintain high code quality standards.
+- **prefer-webp-images** (optional) - a local custom rule that errors on
+  references to `.png`/`.jpg`/`.jpeg`/`.gif`/`.bmp` images and suggests
+  converting them at [tools.sturge.dev/webp](https://tools.sturge.dev/webp)
 
 #### Prettier
 
@@ -60,17 +93,24 @@ Configured with two powerful plugins:
 - **prettier-plugin-organize-imports** - Automatically sorts and removes unused imports
 - **prettier-plugin-tailwindcss** - Sorts Tailwind class names consistently
 
-Why Prettier? It eliminates debates about code style by automatically formatting code. The organize-imports plugin keeps imports clean, and the Tailwind plugin ensures class names follow the recommended ordering.
-
 ### Optional E2E Testing
 
-When you include E2E testing (via prompt or `--with-e2e` flag), you get:
+When you include E2E testing (via wizard or `--with-e2e` flag), you get:
 
 - **Playwright** - Modern, reliable E2E testing framework
 - **Allure Reports** - Beautiful, detailed test reports
 - Pre-configured test setup with example tests
 - HTML reports and Allure integration
 
+### Git Integration
+
+After scaffolding (when not already inside a git repository), the CLI:
+
+1. Runs `git init`
+2. Installs a pre-commit hook that formats and lints staged files
+   (the same hook as `npm run setFormatToPrecommitHook`)
+3. Creates an initial commit
+
 ### Dependency Management
 
 - **Exact version pinning** - All dependencies use exact versions (no `^` or `~`)
@@ -79,7 +119,7 @@ When you include E2E testing (via prompt or `--with-e2e` flag), you get:
 
 ### GitHub Actions Workflows
 
-Two CI workflows are included in the generated projects:
+Up to three CI workflows are included in generated projects:
 
 1. **Code Checks** (`.github/workflows/check.yml`)
 
@@ -89,10 +129,16 @@ Two CI workflows are included in the generated projects:
    - Production build verification
 
 2. **E2E Tests** (`.github/workflows/e2e.yml`) - if E2E is included
+
    - Runs Playwright tests in CI
    - Uploads test reports as artifacts
    - Configures Allure results
 
+3. **Lighthouse CI** (`.github/workflows/lighthouse.yml`) - if Lighthouse is included
+   - Builds the app and audits it with Lighthouse
+   - Fails CI below score budgets: accessibility ≥ 95, SEO ≥ 95, performance ≥ 85
+   - Budgets live in `lighthouserc.json`
+
 ## Available Scripts
 
 ### Development
@@ -155,14 +201,23 @@ Runs basic troubleshooting checks:
 
 ```
 my-app/
+├── public/
+│   ├── fonts/          # Self-hosted Inter (variable woff2)
+│   └── robots.txt
 ├── src/
-│   ├── pages/          # Page components
+│   ├── pages/          # Route pages
 │   │   ├── Home/
-│   │   └── About/
+│   │   ├── About/
+│   │   └── NotFound/
+│   ├── components/     # Reusable components (Button example)
+│   ├── types/          # Shared TypeScript types
+│   ├── utils/          # Utility functions (optional)
 │   ├── App.tsx         # Main app with routing
 │   ├── main.tsx        # Entry point
-│   └── app.css         # Tailwind directives
+│   └── app.css         # Tailwind theme + base styles
 ├── e2e/                # E2E tests (optional)
+├── eslint-rules/       # Local ESLint rules (optional)
+├── lighthouserc.json   # Lighthouse budgets (optional)
 ├── .github/            # GitHub Actions workflows
 └── package.json
 ```
@@ -170,12 +225,12 @@ my-app/
 ## Why This Stack?
 
 - **Modern**: Latest versions of React, Vite, and Tailwind
-- **Lightweight**: Minimal dependencies, under 1MB node_modules (before dev deps)
+- **Lightweight**: Minimal dependencies, fast installs and builds
 - **Type-safe**: Full TypeScript support with strict checking
-- **Fast**: Vite's instant HMR and optimized builds
-- **Accessible**: Built-in a11y linting ensures inclusive UIs
+- **Fast**: Vite's instant HMR, route-level code splitting, self-hosted fonts
+- **Accessible**: Built-in a11y linting, skip links, focus styles
 - **Maintainable**: Automated formatting and linting prevent technical debt
-- **CI-ready**: Workflows for testing and validation out of the box
+- **CI-ready**: Workflows for checks, E2E tests, and Lighthouse budgets out of the box
 
 ## License
 

package/bin/index.js

@@ -1,17 +1,54 @@
 #!/usr/bin/env node
 
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { readdir, mkdir, readFile, writeFile, copyFile, stat, rm } from 'fs/promises';
-import { existsSync } from 'fs';
+import * as p from '@clack/prompts';
 import { spawn } from 'child_process';
-import * as readline from 'readline';
+import { existsSync } from 'fs';
+import { chmod, copyFile, mkdir, readdir, readFile, rm, writeFile } from 'fs/promises';
+import { dirname, join, relative, sep } from 'path';
+import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const args = process.argv.slice(2);
 
+const FEATURES = [
+  {
+    id: 'e2e',
+    flag: 'e2e',
+    label: 'E2E testing (Playwright + Allure)'
+  },
+  {
+    id: 'utils',
+    flag: 'utils',
+    label: 'Utility functions (classNames, Storage, useUrlState, safeTimeout)'
+  },
+  {
+    id: 'lighthouse',
+    flag: 'lighthouse',
+    label: 'Lighthouse CI workflow (a11y/SEO/performance budgets)'
+  },
+  {
+    id: 'webpLint',
+    flag: 'webp-lint',
+    label: 'ESLint rule: prefer WebP images'
+  }
+];
+
+// Flags that consume the next argument as their value; all others are boolean.
+const VALUE_FLAGS = new Set(['dir', 'directory']);
+
+const PRE_COMMIT_HOOK = `#!/bin/bash
+
+STAGED_JS_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(tsx?|js)$' || true)
+
+if [ -n "$STAGED_JS_FILES" ]; then
+  echo "$STAGED_JS_FILES" | xargs npx prettier --write --ignore-unknown || exit 1
+  echo "$STAGED_JS_FILES" | xargs npx eslint --fix || exit 1
+  echo "$STAGED_JS_FILES" | xargs git add
+fi
+`;
+
 function parseArgs(args) {
   const parsed = {
     projectName: null,
@@ -23,7 +60,7 @@ function parseArgs(args) {
     if (arg.startsWith('--')) {
       const key = arg.slice(2);
       const nextArg = args[i + 1];
-      if (nextArg && !nextArg.startsWith('--')) {
+      if (VALUE_FLAGS.has(key) && nextArg && !nextArg.startsWith('--')) {
         parsed.flags[key] = nextArg;
         i++;
       } else {
@@ -47,47 +84,103 @@ function validateProjectName(name) {
   return null;
 }
 
-async function copyDirectory(src, dest, excludePaths = []) {
+function printUsage() {
+  console.log('\nUsage: npm create react-adam@latest <project-name> [options]');
+  console.log('\nOptions:');
+  console.log('  --dir <path>          Create the project in a specific directory');
+  console.log('  --yes                 Skip the wizard; include every feature not disabled by a flag');
+  console.log('  --with-e2e            Include E2E testing setup (Playwright + Allure)');
+  console.log('  --no-e2e              Skip E2E testing setup');
+  console.log('  --with-utils          Include utility functions (classNames, Storage, useUrlState)');
+  console.log('  --no-utils            Skip utility functions');
+  console.log('  --with-lighthouse     Include Lighthouse CI workflow');
+  console.log('  --no-lighthouse       Skip Lighthouse CI workflow');
+  console.log('  --with-webp-lint      Include the prefer-webp-images ESLint rule');
+  console.log('  --no-webp-lint        Skip the prefer-webp-images ESLint rule');
+}
+
+async function resolveFeatures(flags) {
+  const resolved = {};
+
+  for (const feature of FEATURES) {
+    if (flags[`with-${feature.flag}`]) {
+      resolved[feature.id] = true;
+    } else if (flags[`no-${feature.flag}`]) {
+      resolved[feature.id] = false;
+    }
+  }
+
+  const unresolved = FEATURES.filter((feature) => resolved[feature.id] === undefined);
+  if (unresolved.length === 0) {
+    return resolved;
+  }
+
+  const isNonInteractive = flags.yes || !process.stdin.isTTY || !process.stdout.isTTY;
+  if (isNonInteractive) {
+    for (const feature of unresolved) {
+      resolved[feature.id] = true;
+    }
+    return resolved;
+  }
+
+  p.intro('create-react-adam');
+  const selected = await p.multiselect({
+    message: 'Select features',
+    options: unresolved.map((feature) => ({
+      value: feature.id,
+      label: feature.label
+    })),
+    initialValues: unresolved.map((feature) => feature.id),
+    required: false
+  });
+
+  if (p.isCancel(selected)) {
+    p.cancel('Scaffold cancelled.');
+    process.exit(1);
+  }
+
+  for (const feature of unresolved) {
+    resolved[feature.id] = selected.includes(feature.id);
+  }
+  return resolved;
+}
+
+// Local dev/build artifacts that must never be copied into a scaffold
+// (npm excludes most of these from the published package anyway).
+const ALWAYS_SKIP = new Set([
+  'node_modules',
+  'dist',
+  '.DS_Store',
+  'package-lock.json',
+  'playwright-report',
+  'test-results',
+  'allure-results'
+]);
+
+async function copyDirectory(src, dest, excludePaths = [], root = src) {
   await mkdir(dest, { recursive: true });
   const entries = await readdir(src, { withFileTypes: true });
 
   for (const entry of entries) {
+    if (ALWAYS_SKIP.has(entry.name)) {
+      continue;
+    }
     const srcPath = join(src, entry.name);
     const destPath = join(dest, entry.name);
+    const relPath = relative(root, srcPath).split(sep).join('/');
 
-    const shouldExclude = excludePaths.some(excludePath => {
-      if (entry.isDirectory() && entry.name === excludePath) {
-        return true;
-      }
-      return srcPath.endsWith(`/${excludePath}`) || srcPath.endsWith(`\\${excludePath}`);
-    });
-
-    if (shouldExclude) {
+    if (excludePaths.includes(relPath)) {
       continue;
     }
 
     if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath, excludePaths);
+      await copyDirectory(srcPath, destPath, excludePaths, root);
     } else {
       await copyFile(srcPath, destPath);
     }
   }
 }
 
-function askQuestion(query) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  return new Promise((resolve) => {
-    rl.question(query, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-
 async function replaceInFile(filePath, replacements) {
   let content = await readFile(filePath, 'utf-8');
   for (const [key, value] of Object.entries(replacements)) {
@@ -103,6 +196,7 @@ function runCommand(command, args, cwd) {
       stdio: 'inherit'
     });
 
+    child.on('error', reject);
     child.on('close', (code) => {
       if (code !== 0) {
         reject(new Error(`Command failed with exit code ${code}`));
@@ -113,19 +207,65 @@ function runCommand(command, args, cwd) {
   });
 }
 
+function runCommandQuiet(command, args, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: 'ignore'
+    });
+
+    child.on('error', () => resolve(-1));
+    child.on('close', (code) => resolve(code));
+  });
+}
+
+async function setupGit(projectPath) {
+  const gitAvailable = (await runCommandQuiet('git', ['--version'])) === 0;
+  if (!gitAvailable) {
+    console.log('\nGit not found; skipping repository setup.');
+    return;
+  }
+
+  const insideRepo =
+    (await runCommandQuiet('git', ['rev-parse', '--is-inside-work-tree'], projectPath)) === 0;
+  if (insideRepo) {
+    console.log(
+      '\nAlready inside a git repository; skipping git init.' +
+        '\nAfter setting up your own repo, run: npm run setFormatToPrecommitHook'
+    );
+    return;
+  }
+
+  try {
+    await runCommand('git', ['init', '--quiet'], projectPath);
+
+    const hookPath = join(projectPath, '.git', 'hooks', 'pre-commit');
+    await writeFile(hookPath, PRE_COMMIT_HOOK, 'utf-8');
+    await chmod(hookPath, 0o755);
+
+    await runCommand('git', ['add', '-A'], projectPath);
+    await runCommand(
+      'git',
+      ['commit', '--quiet', '-m', 'Initial commit from create-react-adam'],
+      projectPath
+    );
+    console.log('\nInitialized a git repository with a formatting pre-commit hook.');
+  } catch (error) {
+    console.warn(
+      `\nWarning: git setup did not complete (${error.message}).` +
+        '\nYou can finish it manually with: git init && git add -A && git commit' +
+        '\nThen run: npm run setFormatToPrecommitHook'
+    );
+  }
+}
+
 async function main() {
   const { projectName, flags } = parseArgs(args);
 
   const validationError = validateProjectName(projectName);
   if (validationError) {
     console.error(`Error: ${validationError}`);
-    console.log('\nUsage: npm create react-adam@latest <project-name> [options]');
-    console.log('\nOptions:');
-    console.log('  --dir <path>       Create the project in a specific directory');
-    console.log('  --with-e2e         Include E2E testing setup (Playwright + Allure)');
-    console.log('  --no-e2e           Skip E2E testing setup');
-    console.log('  --with-utils       Include utility functions (classNames, Storage, useUrlState)');
-    console.log('  --no-utils         Skip utility functions');
+    printUsage();
     process.exit(1);
   }
 
@@ -137,80 +277,104 @@ async function main() {
     process.exit(1);
   }
 
-  let includeE2E = false;
-  if (flags['with-e2e']) {
-    includeE2E = true;
-  } else if (flags['no-e2e']) {
-    includeE2E = false;
-  } else {
-    const answer = await askQuestion('Include E2E testing setup (Playwright + Allure)? (y/N): ');
-    includeE2E = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
-  }
-
-  let includeUtils = false;
-  if (flags['with-utils']) {
-    includeUtils = true;
-  } else if (flags['no-utils']) {
-    includeUtils = false;
-  } else {
-    const answer = await askQuestion('Include utility functions (classNames, Storage, useUrlState)? (y/N): ');
-    includeUtils = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
-  }
+  const features = await resolveFeatures(flags);
 
   console.log(`Creating a new Adam React app in ${projectPath}...`);
+  const enabled = FEATURES.filter((feature) => features[feature.id]);
+  console.log(
+    enabled.length > 0
+      ? `Features: ${enabled.map((feature) => feature.label).join(', ')}`
+      : 'Features: none (core stack only)'
+  );
 
   const templatePath = join(__dirname, '..', 'template');
   const excludePaths = [];
-  
-  if (!includeE2E) {
-    excludePaths.push('e2e');
-  }
 
-  if (!includeUtils) {
-    excludePaths.push('utils');
+  if (!features.e2e) {
+    excludePaths.push('e2e', '.github/workflows/e2e.yml');
   }
-
-  await copyDirectory(templatePath, projectPath, excludePaths);
-
-  // Rename gitignore to .gitignore (npm doesn't publish .gitignore files)
-  const gitignorePath = join(projectPath, 'gitignore');
-  if (existsSync(gitignorePath)) {
-    await copyFile(gitignorePath, join(projectPath, '.gitignore'));
-    await rm(gitignorePath);
+  if (!features.utils) {
+    excludePaths.push('src/utils');
   }
-
-  if (!includeUtils) {
-    await copyFile(
-      join(projectPath, 'src', 'pages', 'Home', 'index.no-utils.tsx'),
-      join(projectPath, 'src', 'pages', 'Home', 'index.tsx')
-    );
-    await copyFile(
-      join(projectPath, 'src', 'pages', 'About', 'index.no-utils.tsx'),
-      join(projectPath, 'src', 'pages', 'About', 'index.tsx')
-    );
-    await rm(join(projectPath, 'src', 'pages', 'Home', 'index.no-utils.tsx'));
-    await rm(join(projectPath, 'src', 'pages', 'About', 'index.no-utils.tsx'));
-  } else {
-    await rm(join(projectPath, 'src', 'pages', 'Home', 'index.no-utils.tsx'));
-    await rm(join(projectPath, 'src', 'pages', 'About', 'index.no-utils.tsx'));
+  if (!features.lighthouse) {
+    excludePaths.push('.github/workflows/lighthouse.yml', 'lighthouserc.json');
+  }
+  if (!features.webpLint) {
+    excludePaths.push('eslint-rules');
   }
 
-  const replacements = {
-    '__PROJECT_NAME__': projectName
-  };
+  let createdProjectDir = false;
+  try {
+    createdProjectDir = true;
+    await copyDirectory(templatePath, projectPath, excludePaths);
+
+    // npm never publishes .gitignore/.npmrc files, so the template ships them
+    // without the leading dot and we restore the real names here.
+    const dotfileRenames = [
+      ['gitignore', '.gitignore'],
+      ['npmrc', '.npmrc'],
+      [join('e2e', 'gitignore'), join('e2e', '.gitignore')]
+    ];
+    for (const [from, to] of dotfileRenames) {
+      const fromPath = join(projectPath, from);
+      if (existsSync(fromPath)) {
+        await copyFile(fromPath, join(projectPath, to));
+        await rm(fromPath);
+      }
+    }
 
-  await replaceInFile(join(projectPath, 'package.json'), replacements);
-  await replaceInFile(join(projectPath, 'index.html'), replacements);
-  await replaceInFile(join(projectPath, 'README.md'), replacements);
+    // Resolve .no-utils page variants
+    for (const page of ['Home', 'About']) {
+      const variantPath = join(projectPath, 'src', 'pages', page, 'index.no-utils.tsx');
+      if (!features.utils) {
+        await copyFile(variantPath, join(projectPath, 'src', 'pages', page, 'index.tsx'));
+      }
+      await rm(variantPath);
+    }
 
-  console.log('\nInstalling dependencies...');
-  await runCommand('npm', ['install'], projectPath);
+    // Resolve the eslint config variant (with or without the WebP rule)
+    const noWebpConfigPath = join(projectPath, 'eslint.config.no-webp.js');
+    if (!features.webpLint) {
+      await copyFile(noWebpConfigPath, join(projectPath, 'eslint.config.js'));
+    }
+    await rm(noWebpConfigPath);
+
+    // README.md uses {{PROJECT_NAME}} because Prettier's markdown formatter
+    // rewrites __PROJECT_NAME__ (underscore emphasis) to **PROJECT_NAME**.
+    const replacements = {
+      __PROJECT_NAME__: projectName,
+      '{{PROJECT_NAME}}': projectName
+    };
+
+    const filesToReplace = [
+      'package.json',
+      'index.html',
+      'README.md',
+      join('src', 'pages', 'Home', 'index.tsx'),
+      join('src', 'pages', 'About', 'index.tsx'),
+      join('src', 'pages', 'NotFound', 'index.tsx')
+    ];
+    for (const file of filesToReplace) {
+      await replaceInFile(join(projectPath, file), replacements);
+    }
 
-  if (includeE2E) {
-    console.log('\nInstalling E2E dependencies...');
-    await runCommand('npm', ['install'], join(projectPath, 'e2e'));
+    console.log('\nInstalling dependencies...');
+    await runCommand('npm', ['install'], projectPath);
+
+    if (features.e2e) {
+      console.log('\nInstalling E2E dependencies...');
+      await runCommand('npm', ['install'], join(projectPath, 'e2e'));
+    }
+  } catch (error) {
+    if (createdProjectDir) {
+      await rm(projectPath, { recursive: true, force: true });
+      console.error(`\nScaffolding failed; removed ${projectPath}`);
+    }
+    throw error;
   }
 
+  await setupGit(projectPath);
+
   console.log('\n✓ Success! Created', projectName, 'at', projectPath);
   console.log('\nInside that directory, you can run several commands:\n');
   console.log('  npm run dev');
@@ -221,8 +385,8 @@ async function main() {
   console.log('    Previews the production build.\n');
   console.log('  npm run lint');
   console.log('    Runs the linter.\n');
-  
-  if (includeE2E) {
+
+  if (features.e2e) {
     console.log('  npm run test:e2e');
     console.log('    Runs E2E tests with Playwright.\n');
     console.log('  npm run test:e2e:ui');
@@ -230,7 +394,7 @@ async function main() {
     console.log('  npm run test:e2e:report');
     console.log('    Generates and opens Allure report.\n');
   }
-  
+
   console.log('We suggest that you begin by typing:\n');
   console.log(`  cd ${projectName}`);
   console.log('  npm run dev\n');
@@ -240,4 +404,3 @@ main().catch((error) => {
   console.error('Error:', error.message);
   process.exit(1);
 });
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-react-adam",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Create opinionated React apps with TypeScript, Vite, Wouter, and Tailwind CSS",
   "type": "module",
   "bin": {
@@ -8,7 +8,10 @@
   },
   "files": [
     "bin",
-    "template"
+    "template",
+    "!template/package-lock.json",
+    "!template/node_modules",
+    "!template/dist"
   ],
   "keywords": [
     "react",
@@ -38,6 +41,8 @@
     "itDoesNotWork": "echo 'Wrong Directory'",
     "cleanup": "rm -rf ./tmp/* && rm -rf ./template/node_modules && rm -rf ./template/dist && rm -rf ./template/package-lock.json && echo 'Template Dev Files Deleted, you must run npm install in the template directory for those features'",
     "dev": "npm run cleanup && TIMESTAMP=$(date +%Y%m%d-%H%M%S) && npm link && cd ./tmp && npx create-react-adam test-app-$TIMESTAMP --with-e2e --with-utils && cd test-app-$TIMESTAMP && npm run dev"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.7.0"
   }
 }
-

package/template/.github/workflows/check.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: "24.11.1"
+          node-version: "24.18.0"
           cache: "npm"
 
       - name: Install CLI dependencies