devstarter-tool 0.2.2 → 0.3.0

package/README.md

@@ -4,12 +4,12 @@ CLI to generate projects with best practices and predefined configurations.
 
 ## Features
 
-- **Project structures**: Basic (single project) or Monorepo (full-stack)
+- **Project scaffolding**: Create frontend, backend, or monorepo projects in seconds
+- **`add` command**: Add features like ESLint, Vitest, Prettier, CI, Docker, and Tailwind CSS to existing projects
+- **Interactive prompts**: Guided project creation or flag-based configuration
 - **Automatic dependency installation**: No need to run `npm install` manually
-- **Vitest integration**: Optional testing setup with one flag
 - **Package manager detection**: Automatically uses npm, pnpm, or yarn
 - **Git initialization**: Optional repository setup
-- **Interactive prompts**: Guided project creation
 - **Dry-run mode**: Preview changes before creating files
 
 ## Installation
@@ -36,18 +36,27 @@ devstarter init my-app -y
 # Frontend project with Vitest
 devstarter init my-app --type frontend --vitest
 
+# Add features to an existing project
+devstarter add prettier
+devstarter add eslint
+devstarter add tailwind
+devstarter add docker
+devstarter add ci
+
 # Preview without creating files
 devstarter init my-app --dry-run
 ```
 
-## Usage
+## Commands
+
+### `devstarter init`
+
+Scaffolds a new project from a template.
 
 ```bash
 devstarter init [project-name] [options]
 ```
 
-### Options
-
 | Option | Description |
 |--------|-------------|
 | `-y, --yes` | Use default values without prompting |
@@ -55,9 +64,10 @@ devstarter init [project-name] [options]
 | `--template <name>` | Template to use (e.g., `basic`, `react`) |
 | `--vitest` | Add Vitest for testing |
 | `--no-git` | Skip Git repository initialization |
+| `--no-vitest` | Skip Vitest testing framework setup |
 | `--dry-run` | Preview changes without creating files |
 
-### Examples
+#### Examples
 
 ```bash
 # Full interactive mode
@@ -79,6 +89,55 @@ devstarter init my-app --type frontend -y
 devstarter init my-app --no-git
 ```
 
+### `devstarter add`
+
+Adds features to an existing project. Automatically detects features already configured and skips them.
+
+```bash
+devstarter add [feature] [options]
+```
+
+| Option | Description |
+|--------|-------------|
+| `--list` | List all available features |
+| `-y, --yes` | Add all available features without prompting |
+| `--dry-run` | Show what would be added without making changes |
+
+#### Available Features
+
+| Feature | Description | What it adds |
+|---------|-------------|--------------|
+| `eslint` | Linter for JavaScript and TypeScript | `eslint.config.js`, lint script, ESLint + typescript-eslint deps |
+| `vitest` | Unit testing framework | `vitest.config.ts`, test scripts, Vitest dep |
+| `prettier` | Code formatter | `.prettierrc`, format script, Prettier dep |
+| `ci` | CI/CD pipeline | GitHub Actions workflow (`.github/workflows/ci.yml`) or GitLab CI (`.gitlab-ci.yml`) with lint, test, and build steps |
+| `docker` | Docker containerization | `Dockerfile` (multi-stage build), `docker-compose.yml`, `.dockerignore`. Auto-detects frontend (nginx) vs backend (node) |
+| `tailwind` | Tailwind CSS v4 | `tailwindcss` + `@tailwindcss/vite` deps, Vite plugin config, `@import "tailwindcss"` in CSS |
+
+#### Examples
+
+```bash
+# Add a specific feature
+devstarter add prettier
+devstarter add eslint
+devstarter add vitest
+devstarter add tailwind
+devstarter add docker
+devstarter add ci
+
+# Interactive mode - choose from available features
+devstarter add
+
+# Add all available features at once
+devstarter add -y
+
+# List available features
+devstarter add --list
+
+# Preview changes
+devstarter add prettier --dry-run
+```
+
 ## Project Structures
 
 ### Basic (single project)
@@ -130,23 +189,6 @@ my-app/
 |----------|-------------|
 | `basic` | Express + TypeScript |
 
-## Vitest Integration
-
-When using `--vitest`, the CLI adds:
-
-- `vitest` as a dev dependency
-- `vitest.config.ts` with basic configuration
-- `test` and `test:run` scripts in package.json
-
-```bash
-# Create project with Vitest
-devstarter init my-app --vitest
-
-# Then run tests
-cd my-app
-npm test
-```
-
 ## Requirements
 
 - Node.js 18+
@@ -175,7 +217,9 @@ node dist/cli.js init test-app --dry-run
 |--------|-------------|
 | `npm run build` | Compile TypeScript and copy templates |
 | `npm run dev` | Watch mode for development |
-| `npm run test` | Run tests |
+| `npm run test` | Run tests in watch mode |
+| `npm run test:run` | Single test run |
+| `npm run test:coverage` | Coverage with HTML + text reports |
 | `npm run lint` | Run ESLint |
 | `npm run format` | Format code with Prettier |
 

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { initCommand } from './commands/init.js';
+import { addCommand } from './commands/add.js';
 const program = new Command();
 program
     .name('devstarter')
@@ -16,4 +17,11 @@ program
     .option('--no-git', 'Skip git repository initialization')
     .option('--vitest', 'Add Vitest for testing')
     .action(initCommand);
+program
+    .command('add [feature]')
+    .description('Add a feature to an existing project')
+    .option('--dry-run', 'Show what would be added without making changes')
+    .option('--list', 'List available features')
+    .option('-y, --yes', 'Add all available features without prompting')
+    .action(addCommand);
 program.parse(process.argv);

package/dist/commands/add/collector.js

@@ -0,0 +1,47 @@
+import { detectProjectContext } from '../../utils/detectProjectContext.js';
+import { PromptCancelledError } from '../../prompts/initPrompts.js';
+import { getAllFeatures } from './registry.js';
+import { resolveFeatureArg } from './resolvers.js';
+import { askFeatures } from '../../prompts/addPrompts.js';
+export async function collectAddContext(featureArg, options) {
+    const projectContext = await detectProjectContext();
+    if (featureArg) {
+        const featureId = resolveFeatureArg(featureArg);
+        return {
+            projectRoot: projectContext.root,
+            features: [featureId],
+            isDryRun: Boolean(options.dryRun),
+            packageManager: projectContext.packageManager,
+        };
+    }
+    // Filter out already-detected features
+    const allFeatures = getAllFeatures();
+    const available = [];
+    for (const feature of allFeatures) {
+        const detected = await feature.detect(projectContext);
+        if (!detected) {
+            available.push(feature);
+        }
+    }
+    if (available.length === 0) {
+        throw new Error('All available features are already configured.');
+    }
+    if (options.yes) {
+        return {
+            projectRoot: projectContext.root,
+            features: available.map((f) => f.id),
+            isDryRun: Boolean(options.dryRun),
+            packageManager: projectContext.packageManager,
+        };
+    }
+    const answer = await askFeatures(available);
+    if (answer.features.length === 0) {
+        throw new PromptCancelledError();
+    }
+    return {
+        projectRoot: projectContext.root,
+        features: answer.features,
+        isDryRun: Boolean(options.dryRun),
+        packageManager: projectContext.packageManager,
+    };
+}

package/dist/commands/add/registry.js

@@ -0,0 +1,24 @@
+import { eslintFeature } from '../../features/eslint.js';
+import { vitestFeature } from '../../features/vitest.js';
+import { prettierFeature } from '../../features/prettier.js';
+import { ciFeature } from '../../features/ci.js';
+import { dockerFeature } from '../../features/docker.js';
+import { tailwindFeature } from '../../features/tailwind.js';
+const features = [
+    eslintFeature,
+    vitestFeature,
+    prettierFeature,
+    ciFeature,
+    dockerFeature,
+    tailwindFeature,
+];
+const featureMap = new Map(features.map((f) => [f.id, f]));
+export function getAvailableFeatureIds() {
+    return features.map((f) => f.id);
+}
+export function getFeature(id) {
+    return featureMap.get(id);
+}
+export function getAllFeatures() {
+    return features;
+}

package/dist/commands/add/resolvers.js

@@ -0,0 +1,8 @@
+import { getAvailableFeatureIds } from './registry.js';
+export function resolveFeatureArg(arg) {
+    const available = getAvailableFeatureIds();
+    if (!available.includes(arg)) {
+        throw new Error(`Unknown feature "${arg}". Available: ${available.join(', ')}`);
+    }
+    return arg;
+}

package/dist/commands/add.js

@@ -0,0 +1,65 @@
+import { PromptCancelledError } from '../prompts/initPrompts.js';
+import { styles } from '../utils/styles.js';
+import { detectProjectContext } from '../utils/detectProjectContext.js';
+import { installDependencies } from '../utils/installDependencies.js';
+import { getAllFeatures, getFeature } from './add/registry.js';
+import { collectAddContext } from './add/collector.js';
+export async function addCommand(featureArg, options) {
+    try {
+        if (options.list) {
+            printFeatureList();
+            return;
+        }
+        const context = await collectAddContext(featureArg, options);
+        if (context.isDryRun) {
+            printDryRun(context.features);
+            return;
+        }
+        const projectContext = await detectProjectContext(context.projectRoot);
+        for (const featureId of context.features) {
+            const feature = getFeature(featureId);
+            console.log(`${styles.info('Adding')} ${feature.name}...`);
+            await feature.apply(projectContext);
+            console.log(`${styles.success('Added')} ${feature.name}`);
+        }
+        console.log(`\n${styles.info('Installing dependencies...')}`);
+        installDependencies(context.projectRoot, context.packageManager);
+        printAddSummary(context.features);
+    }
+    catch (error) {
+        handleError(error);
+    }
+}
+function printFeatureList() {
+    const features = getAllFeatures();
+    console.log(`\n${styles.title('Available features')}\n`);
+    for (const feature of features) {
+        console.log(`  ${styles.highlight(feature.id)} - ${feature.description}`);
+    }
+    console.log('');
+}
+function printDryRun(featureIds) {
+    console.log(`\n${styles.warning('Dry run – no changes will be made')}\n`);
+    console.log(styles.title('Features to add'));
+    for (const id of featureIds) {
+        const feature = getFeature(id);
+        console.log(`  ${styles.info('-')} ${feature.name}: ${feature.description}`);
+    }
+    console.log('');
+}
+function printAddSummary(featureIds) {
+    console.log(`\n${styles.success('Done!')}\n`);
+    console.log(styles.title('Added features'));
+    for (const id of featureIds) {
+        const feature = getFeature(id);
+        console.log(`  ${styles.success('-')} ${feature.name}`);
+    }
+    console.log('');
+}
+function handleError(error) {
+    if (error instanceof PromptCancelledError) {
+        console.log(`\n${styles.muted('Operation cancelled')}`);
+        return;
+    }
+    console.error(`\n${styles.error('Error:')} ${error.message}`);
+}

package/dist/features/ci.js

@@ -0,0 +1,158 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import prompts from 'prompts';
+async function detect(context) {
+    // Check for GitLab CI
+    if (await fs.pathExists(path.join(context.root, '.gitlab-ci.yml'))) {
+        return true;
+    }
+    // Check for GitHub Actions (directory must exist and contain at least one .yml)
+    const workflowsDir = path.join(context.root, '.github', 'workflows');
+    if (await fs.pathExists(workflowsDir)) {
+        const files = await fs.readdir(workflowsDir);
+        if (files.some((f) => f.endsWith('.yml') || f.endsWith('.yaml'))) {
+            return true;
+        }
+    }
+    return false;
+}
+function getInstallCommand(context) {
+    switch (context.packageManager) {
+        case 'pnpm':
+            return 'pnpm install --frozen-lockfile';
+        case 'yarn':
+            return 'yarn install --frozen-lockfile';
+        default:
+            return 'npm ci';
+    }
+}
+function getRunCommand(context, script) {
+    switch (context.packageManager) {
+        case 'pnpm':
+            return `pnpm run ${script}`;
+        case 'yarn':
+            return `yarn ${script}`;
+        default:
+            return `npm run ${script}`;
+    }
+}
+function getScripts(packageJson) {
+    return packageJson.scripts ?? {};
+}
+function generateGitHubWorkflow(context) {
+    const scripts = getScripts(context.packageJson);
+    const installCmd = getInstallCommand(context);
+    const steps = [
+        '      - uses: actions/checkout@v4',
+        '      - uses: actions/setup-node@v4',
+        '        with:',
+        '          node-version: 20',
+        `      - run: ${installCmd}`,
+    ];
+    if (scripts.lint) {
+        steps.push(`      - run: ${getRunCommand(context, 'lint')}`);
+    }
+    if (scripts.test) {
+        steps.push(`      - run: ${getRunCommand(context, 'test')}`);
+    }
+    if (scripts.build) {
+        steps.push(`      - run: ${getRunCommand(context, 'build')}`);
+    }
+    return `name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+${steps.join('\n')}
+`;
+}
+function generateGitLabCI(context) {
+    const scripts = getScripts(context.packageJson);
+    const installCmd = getInstallCommand(context);
+    let config = `stages:
+  - install
+  - lint
+  - test
+  - build
+
+install:
+  stage: install
+  image: node:20-alpine
+  script:
+    - ${installCmd}
+  cache:
+    paths:
+      - node_modules/
+`;
+    if (scripts.lint) {
+        config += `
+lint:
+  stage: lint
+  image: node:20-alpine
+  script:
+    - ${getRunCommand(context, 'lint')}
+  cache:
+    paths:
+      - node_modules/
+`;
+    }
+    if (scripts.test) {
+        config += `
+test:
+  stage: test
+  image: node:20-alpine
+  script:
+    - ${getRunCommand(context, 'test')}
+  cache:
+    paths:
+      - node_modules/
+`;
+    }
+    if (scripts.build) {
+        config += `
+build:
+  stage: build
+  image: node:20-alpine
+  script:
+    - ${getRunCommand(context, 'build')}
+  cache:
+    paths:
+      - node_modules/
+`;
+    }
+    return config;
+}
+async function apply(context) {
+    const { provider } = await prompts({
+        type: 'select',
+        name: 'provider',
+        message: 'Which CI provider?',
+        choices: [
+            { title: 'GitHub Actions', value: 'github' },
+            { title: 'GitLab CI', value: 'gitlab' },
+        ],
+    });
+    if (!provider) {
+        throw new Error('CI provider selection cancelled');
+    }
+    if (provider === 'github') {
+        const workflowDir = path.join(context.root, '.github', 'workflows');
+        await fs.ensureDir(workflowDir);
+        await fs.writeFile(path.join(workflowDir, 'ci.yml'), generateGitHubWorkflow(context));
+    }
+    else {
+        await fs.writeFile(path.join(context.root, '.gitlab-ci.yml'), generateGitLabCI(context));
+    }
+}
+export const ciFeature = {
+    id: 'ci',
+    name: 'CI',
+    description: 'Continuous integration with GitHub Actions or GitLab CI',
+    detect,
+    apply,
+};

package/dist/features/docker.js

@@ -0,0 +1,97 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+async function detect(context) {
+    const configFiles = [
+        'Dockerfile',
+        'docker-compose.yml',
+        'docker-compose.yaml',
+        'compose.yml',
+        'compose.yaml',
+    ];
+    for (const file of configFiles) {
+        if (await fs.pathExists(path.join(context.root, file))) {
+            return true;
+        }
+    }
+    return false;
+}
+function isFrontend(packageJson) {
+    const deps = {
+        ...(packageJson.dependencies ?? {}),
+        ...(packageJson.devDependencies ?? {}),
+    };
+    return 'vite' in deps;
+}
+function getInstallCommand(context) {
+    switch (context.packageManager) {
+        case 'pnpm':
+            return 'pnpm install --frozen-lockfile';
+        case 'yarn':
+            return 'yarn install --frozen-lockfile';
+        default:
+            return 'npm ci';
+    }
+}
+function generateDockerfile(context) {
+    const installCmd = getInstallCommand(context);
+    const frontend = isFrontend(context.packageJson);
+    if (frontend) {
+        return `FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN ${installCmd}
+COPY . .
+RUN npm run build
+
+FROM nginx:alpine
+COPY --from=build /app/dist /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+`;
+    }
+    return `FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN ${installCmd}
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/package*.json ./
+RUN ${installCmd} --omit=dev
+EXPOSE 3000
+CMD ["node", "dist/index.js"]
+`;
+}
+function generateDockerCompose(context) {
+    const frontend = isFrontend(context.packageJson);
+    const port = frontend ? '8080:80' : '3000:3000';
+    return `services:
+  app:
+    build: .
+    ports:
+      - "${port}"
+    environment:
+      - NODE_ENV=production
+`;
+}
+const DOCKERIGNORE = `node_modules
+dist
+.git
+*.log
+.env
+`;
+async function apply(context) {
+    await fs.writeFile(path.join(context.root, 'Dockerfile'), generateDockerfile(context));
+    await fs.writeFile(path.join(context.root, 'docker-compose.yml'), generateDockerCompose(context));
+    await fs.writeFile(path.join(context.root, '.dockerignore'), DOCKERIGNORE);
+}
+export const dockerFeature = {
+    id: 'docker',
+    name: 'Docker',
+    description: 'Dockerfile, docker-compose, and .dockerignore',
+    detect,
+    apply,
+};

package/dist/features/eslint.js

@@ -0,0 +1,74 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+const ESLINT_CONFIG_TS = `import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    ignores: ['dist/'],
+  },
+);
+`;
+const ESLINT_CONFIG_JS = `import eslint from '@eslint/js';
+
+export default [
+  eslint.configs.recommended,
+  {
+    ignores: ['dist/'],
+  },
+];
+`;
+async function detect(context) {
+    const configFiles = [
+        'eslint.config.js',
+        'eslint.config.mjs',
+        'eslint.config.cjs',
+        '.eslintrc.js',
+        '.eslintrc.json',
+        '.eslintrc.yml',
+        '.eslintrc',
+    ];
+    for (const file of configFiles) {
+        if (await fs.pathExists(path.join(context.root, file))) {
+            return true;
+        }
+    }
+    const deps = {
+        ...(context.packageJson.dependencies ?? {}),
+        ...(context.packageJson.devDependencies ?? {}),
+    };
+    return 'eslint' in deps;
+}
+async function apply(context) {
+    const packageJsonPath = path.join(context.root, 'package.json');
+    const packageJson = await fs.readJson(packageJsonPath);
+    const devDeps = {
+        eslint: '^9.0.0',
+        '@eslint/js': '^9.0.0',
+    };
+    if (context.hasTypescript) {
+        devDeps['typescript-eslint'] = '^8.0.0';
+    }
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        ...devDeps,
+    };
+    packageJson.scripts = {
+        ...packageJson.scripts,
+        lint: 'eslint .',
+    };
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    const configContent = context.hasTypescript
+        ? ESLINT_CONFIG_TS
+        : ESLINT_CONFIG_JS;
+    await fs.writeFile(path.join(context.root, 'eslint.config.js'), configContent);
+}
+export const eslintFeature = {
+    id: 'eslint',
+    name: 'ESLint',
+    description: 'Linter for JavaScript and TypeScript',
+    detect,
+    apply,
+};

package/dist/features/prettier.js

@@ -0,0 +1,55 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+const PRETTIER_CONFIG = `{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 80,
+  "tabWidth": 2
+}
+`;
+async function detect(context) {
+    const configFiles = [
+        '.prettierrc',
+        '.prettierrc.json',
+        '.prettierrc.yaml',
+        '.prettierrc.yml',
+        '.prettierrc.js',
+        '.prettierrc.cjs',
+        '.prettierrc.mjs',
+        'prettier.config.js',
+        'prettier.config.cjs',
+        'prettier.config.mjs',
+    ];
+    for (const file of configFiles) {
+        if (await fs.pathExists(path.join(context.root, file))) {
+            return true;
+        }
+    }
+    const deps = {
+        ...(context.packageJson.dependencies ?? {}),
+        ...(context.packageJson.devDependencies ?? {}),
+    };
+    return 'prettier' in deps;
+}
+async function apply(context) {
+    const packageJsonPath = path.join(context.root, 'package.json');
+    const packageJson = await fs.readJson(packageJsonPath);
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        prettier: '^3.0.0',
+    };
+    packageJson.scripts = {
+        ...packageJson.scripts,
+        format: 'prettier --write .',
+    };
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    await fs.writeFile(path.join(context.root, '.prettierrc'), PRETTIER_CONFIG);
+}
+export const prettierFeature = {
+    id: 'prettier',
+    name: 'Prettier',
+    description: 'Code formatter for JavaScript and TypeScript',
+    detect,
+    apply,
+};

package/dist/features/tailwind.js

@@ -0,0 +1,72 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+async function getWebAppDir(root) {
+    const webDir = path.join(root, 'apps', 'web');
+    if (await fs.pathExists(path.join(webDir, 'package.json'))) {
+        return webDir;
+    }
+    return root;
+}
+async function detect(context) {
+    const targetDir = await getWebAppDir(context.root);
+    const configFiles = [
+        'tailwind.config.js',
+        'tailwind.config.ts',
+        'tailwind.config.mjs',
+        'tailwind.config.cjs',
+    ];
+    for (const file of configFiles) {
+        if (await fs.pathExists(path.join(targetDir, file))) {
+            return true;
+        }
+    }
+    // Check deps in the target package.json
+    const pkgJson = targetDir === context.root
+        ? context.packageJson
+        : await fs.readJson(path.join(targetDir, 'package.json'));
+    const deps = {
+        ...(pkgJson.dependencies ?? {}),
+        ...(pkgJson.devDependencies ?? {}),
+    };
+    return 'tailwindcss' in deps;
+}
+async function apply(context) {
+    const targetDir = await getWebAppDir(context.root);
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    const packageJson = await fs.readJson(packageJsonPath);
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        tailwindcss: '^4.0.0',
+        '@tailwindcss/vite': '^4.0.0',
+    };
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    // Update vite.config.ts to add Tailwind plugin if it exists
+    const viteConfigPath = path.join(targetDir, 'vite.config.ts');
+    if (await fs.pathExists(viteConfigPath)) {
+        const viteConfig = await fs.readFile(viteConfigPath, 'utf-8');
+        if (!viteConfig.includes('@tailwindcss/vite')) {
+            const updated = `import tailwindcss from '@tailwindcss/vite';\n` +
+                viteConfig.replace(/plugins:\s*\[/, 'plugins: [\n    tailwindcss(),');
+            await fs.writeFile(viteConfigPath, updated);
+        }
+    }
+    // Create/update src/index.css with Tailwind import
+    const cssPath = path.join(targetDir, 'src', 'index.css');
+    await fs.ensureDir(path.join(targetDir, 'src'));
+    if (await fs.pathExists(cssPath)) {
+        const existing = await fs.readFile(cssPath, 'utf-8');
+        if (!existing.includes('@import "tailwindcss"')) {
+            await fs.writeFile(cssPath, `@import "tailwindcss";\n\n${existing}`);
+        }
+    }
+    else {
+        await fs.writeFile(cssPath, '@import "tailwindcss";\n');
+    }
+}
+export const tailwindFeature = {
+    id: 'tailwind',
+    name: 'Tailwind CSS',
+    description: 'Utility-first CSS framework',
+    detect,
+    apply,
+};

package/dist/features/vitest.js

@@ -0,0 +1,31 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { setupVitest } from '../utils/setupVitest.js';
+async function detect(context) {
+    const configFiles = [
+        'vitest.config.ts',
+        'vitest.config.js',
+        'vitest.config.mts',
+        'vitest.config.mjs',
+    ];
+    for (const file of configFiles) {
+        if (await fs.pathExists(path.join(context.root, file))) {
+            return true;
+        }
+    }
+    const deps = {
+        ...(context.packageJson.dependencies ?? {}),
+        ...(context.packageJson.devDependencies ?? {}),
+    };
+    return 'vitest' in deps;
+}
+async function apply(context) {
+    await setupVitest(context.root);
+}
+export const vitestFeature = {
+    id: 'vitest',
+    name: 'Vitest',
+    description: 'Unit testing framework for JavaScript and TypeScript',
+    detect,
+    apply,
+};

package/dist/generators/createMonorepo.js

@@ -106,7 +106,6 @@ ${projectName}/
 ## Getting Started
 
 \`\`\`bash
-pnpm install
 pnpm dev
 \`\`\`
 `;

package/dist/prompts/addPrompts.js

@@ -0,0 +1,20 @@
+import prompts from 'prompts';
+import { PromptCancelledError } from './initPrompts.js';
+const onCancel = () => {
+    throw new PromptCancelledError();
+};
+export async function askFeatures(available) {
+    return prompts({
+        type: 'multiselect',
+        name: 'features',
+        message: 'Select features to add:',
+        choices: available.map((f) => ({
+            title: f.name,
+            value: f.id,
+            description: f.description,
+        })),
+        instructions: false,
+        hint: '- Space to select. Return to submit',
+        min: 1,
+    }, { onCancel });
+}

package/dist/types/feature.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/detectProjectContext.js

@@ -0,0 +1,18 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { detectPackageManager } from './detectPackageManager.js';
+export async function detectProjectContext(cwd = process.cwd()) {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    if (!(await fs.pathExists(packageJsonPath))) {
+        throw new Error('No package.json found in current directory. Run this command from a project root.');
+    }
+    const packageJson = await fs.readJson(packageJsonPath);
+    const hasTypescript = await fs.pathExists(path.join(cwd, 'tsconfig.json'));
+    const packageManager = detectPackageManager(cwd);
+    return {
+        root: cwd,
+        packageJson,
+        hasTypescript,
+        packageManager,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devstarter-tool",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "type": "module",
   "description": "CLI to generate projects with best practices (basic or monorepo)",
   "author": "abraham-diaz",