devstarter-tool 0.2.0 → 0.2.2

package/README.md

@@ -2,6 +2,16 @@
 
 CLI to generate projects with best practices and predefined configurations.
 
+## Features
+
+- **Project structures**: Basic (single project) or Monorepo (full-stack)
+- **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
 
 ```bash
@@ -14,12 +24,26 @@ Or run directly with npx:
 npx devstarter-tool init my-app
 ```
 
-## Usage
+## Quick Start
 
-### Basic command
+```bash
+# Interactive mode - guided setup
+devstarter init
+
+# Quick project with defaults
+devstarter init my-app -y
+
+# Frontend project with Vitest
+devstarter init my-app --type frontend --vitest
+
+# Preview without creating files
+devstarter init my-app --dry-run
+```
+
+## Usage
 
 ```bash
-devstarter init [project-name]
+devstarter init [project-name] [options]
 ```
 
 ### Options
@@ -28,7 +52,9 @@ devstarter init [project-name]
 |--------|-------------|
 | `-y, --yes` | Use default values without prompting |
 | `-t, --type <type>` | Project type: `frontend` or `backend` |
-| `--template <name>` | Template to use |
+| `--template <name>` | Template to use (e.g., `basic`, `react`) |
+| `--vitest` | Add Vitest for testing |
+| `--no-git` | Skip Git repository initialization |
 | `--dry-run` | Preview changes without creating files |
 
 ### Examples
@@ -40,11 +66,17 @@ devstarter init
 # Create project with specific name
 devstarter init my-app
 
-# Create frontend project without prompts
+# Frontend with React template
+devstarter init my-app --type frontend --template react
+
+# Backend with testing setup
+devstarter init my-api --type backend --vitest
+
+# Quick frontend with all defaults
 devstarter init my-app --type frontend -y
 
-# Preview what files would be created
-devstarter init my-app --type frontend --dry-run
+# Create without Git
+devstarter init my-app --no-git
 ```
 
 ## Project Structures
@@ -54,10 +86,12 @@ devstarter init my-app --type frontend --dry-run
 ```
 my-app/
 ├── src/
-│   └── main.ts (or main.tsx for React)
+│   └── main.ts
 ├── package.json
-├── README.md
-└── .git/ (if git is initialized)
+├── tsconfig.json
+├── vitest.config.ts   # if --vitest
+├── node_modules/
+└── .git/              # if git initialized
 ```
 
 ### Monorepo (full-stack)
@@ -65,10 +99,16 @@ my-app/
 ```
 my-app/
 ├── apps/
-│   ├── web/        <- frontend template
-│   └── api/        <- backend template
+│   ├── web/           # frontend template
+│   │   ├── src/
+│   │   ├── package.json
+│   │   └── vitest.config.ts
+│   └── api/           # backend template
+│       ├── src/
+│       ├── package.json
+│       └── vitest.config.ts
 ├── packages/
-│   └── shared/     <- shared code
+│   └── shared/        # shared code
 ├── package.json
 ├── pnpm-workspace.yaml
 ├── tsconfig.base.json
@@ -81,7 +121,7 @@ my-app/
 
 | Template | Description |
 |----------|-------------|
-| `basic` | Minimal TypeScript with basic structure |
+| `basic` | Vite + TypeScript |
 | `react` | React 18 + Vite + TypeScript |
 
 ### Backend
@@ -90,24 +130,29 @@ my-app/
 |----------|-------------|
 | `basic` | Express + TypeScript |
 
-## Features
+## Vitest Integration
 
-- Project structure selection (basic or monorepo)
-- Automatic package manager detection (npm, pnpm, yarn)
-- Interactive template selection
-- Optional Git repository initialization
-- Dry-run mode to preview changes
-- Automatic project name normalization (kebab-case)
-- Colored output for better readability
+When using `--vitest`, the CLI adds:
 
-## Development
+- `vitest` as a dev dependency
+- `vitest.config.ts` with basic configuration
+- `test` and `test:run` scripts in package.json
 
-### Requirements
+```bash
+# Create project with Vitest
+devstarter init my-app --vitest
+
+# Then run tests
+cd my-app
+npm test
+```
+
+## Requirements
 
 - Node.js 18+
-- npm, pnpm or yarn
+- npm, pnpm, or yarn
 
-### Setup
+## Development
 
 ```bash
 # Clone repository
@@ -124,7 +169,7 @@ npm run build
 node dist/cli.js init test-app --dry-run
 ```
 
-### Available Scripts
+### Scripts
 
 | Script | Description |
 |--------|-------------|

package/dist/cli.js

@@ -14,6 +14,6 @@ program
     .option('--template <name>', 'Template variant (e.g. basic, react)')
     .option('--dry-run', 'Show what would be generated without creating files')
     .option('--no-git', 'Skip git repository initialization')
-    .option('--no-vitest', 'Skip Vitest testing framework')
+    .option('--vitest', 'Add Vitest for testing')
     .action(initCommand);
 program.parse(process.argv);

package/dist/commands/init/collector.js

@@ -1,5 +1,5 @@
 import { DEFAULT_INIT_OPTIONS } from '../../types/project.js';
-import { askProjectName, askProjectStructure, askInitQuestions, askTemplate, askInitGit, askIncludeVitest, } from '../../prompts/initPrompts.js';
+import { askProjectName, askProjectStructure, askInitQuestions, askTemplate, askInitGit, askUseVitest, } from '../../prompts/initPrompts.js';
 import { normalizeProjectName } from '../../utils/normalize.js';
 import { detectPackageManager } from '../../utils/detectPackageManager.js';
 import { listTemplates } from '../../utils/listTemplate.js';
@@ -40,38 +40,45 @@ async function collectStructure(useDefaults) {
 async function collectBasicContext(projectName, options, useDefaults) {
     const typeFromFlag = resolveProjectType(options.type);
     const gitFlagProvided = options.git !== undefined;
-    const vitestFlagProvided = options.vitest !== undefined;
-    // Obtener tipo de proyecto, initGit e includeVitest
+    // Obtener tipo de proyecto e initGit
     let projectType;
     let initGit;
-    let includeVitest;
     if (useDefaults) {
         projectType = typeFromFlag ?? DEFAULT_INIT_OPTIONS.projectType;
         initGit = gitFlagProvided ? options.git : DEFAULT_INIT_OPTIONS.initGit;
-        includeVitest = vitestFlagProvided ? options.vitest : DEFAULT_INIT_OPTIONS.includeVitest;
     }
     else {
         const answers = await askInitQuestions({
             skipProjectName: true,
             skipProjectType: Boolean(typeFromFlag),
             skipInitGit: gitFlagProvided,
-            skipVitest: vitestFlagProvided,
         });
         projectType = typeFromFlag ?? answers.projectType;
         initGit = gitFlagProvided ? options.git : answers.initGit;
-        includeVitest = vitestFlagProvided ? options.vitest : answers.includeVitest;
     }
     // Obtener template
     const templates = listTemplates(projectType);
     const templateFromFlag = resolveTemplateFlag(options.template, templates);
     const template = await collectTemplate(templateFromFlag, templates, useDefaults);
+    // Obtener useVitest
+    const vitestFlagProvided = options.vitest !== undefined;
+    let useVitest;
+    if (vitestFlagProvided) {
+        useVitest = options.vitest;
+    }
+    else if (useDefaults) {
+        useVitest = DEFAULT_INIT_OPTIONS.useVitest;
+    }
+    else {
+        useVitest = (await askUseVitest()).useVitest;
+    }
     return {
         structure: 'basic',
         projectName,
         projectType,
         template,
         initGit,
-        includeVitest,
+        useVitest,
         packageManager: detectPackageManager(),
         isDryRun: Boolean(options.dryRun),
     };
@@ -81,16 +88,13 @@ async function collectMonorepoContext(projectName, useDefaults, options) {
     const frontendTemplates = listTemplates('frontend');
     const backendTemplates = listTemplates('backend');
     const gitFlagProvided = options.git !== undefined;
-    const vitestFlagProvided = options.vitest !== undefined;
     let webTemplate;
     let apiTemplate;
     let initGit;
-    let includeVitest;
     if (useDefaults) {
         webTemplate = frontendTemplates[0] ?? 'basic';
         apiTemplate = backendTemplates[0] ?? 'basic';
         initGit = gitFlagProvided ? options.git : DEFAULT_INIT_OPTIONS.initGit;
-        includeVitest = vitestFlagProvided ? options.vitest : DEFAULT_INIT_OPTIONS.includeVitest;
     }
     else {
         const webAnswer = await askTemplate({
@@ -110,13 +114,18 @@ async function collectMonorepoContext(projectName, useDefaults, options) {
             const gitAnswer = await askInitGit();
             initGit = gitAnswer.initGit;
         }
-        if (vitestFlagProvided) {
-            includeVitest = options.vitest;
-        }
-        else {
-            const vitestAnswer = await askIncludeVitest();
-            includeVitest = vitestAnswer.includeVitest;
-        }
+    }
+    // Obtener useVitest
+    const vitestFlagProvided = options.vitest !== undefined;
+    let useVitest;
+    if (vitestFlagProvided) {
+        useVitest = options.vitest;
+    }
+    else if (useDefaults) {
+        useVitest = DEFAULT_INIT_OPTIONS.useVitest;
+    }
+    else {
+        useVitest = (await askUseVitest()).useVitest;
     }
     return {
         structure: 'monorepo',
@@ -124,7 +133,7 @@ async function collectMonorepoContext(projectName, useDefaults, options) {
         webTemplate,
         apiTemplate,
         initGit,
-        includeVitest,
+        useVitest,
         packageManager: 'pnpm', // Monorepo usa pnpm por defecto
         isDryRun: Boolean(options.dryRun),
     };

package/dist/generators/createMonorepo.js

@@ -3,8 +3,9 @@ import path from 'node:path';
 import { getTemplatePath } from '../utils/getTemplatePath.js';
 import { copyTemplate } from '../utils/copyTemplate.js';
 import { initGitRepo } from '../utils/git.js';
-import { injectVitest } from '../utils/injectVitest.js';
-export async function createMonorepo({ projectName, webTemplate, apiTemplate, initGit, includeVitest, }) {
+import { setupVitest } from '../utils/setupVitest.js';
+import { installDependencies } from '../utils/installDependencies.js';
+export async function createMonorepo({ projectName, webTemplate, apiTemplate, initGit, useVitest, packageManager, }) {
     // 1. Resolver ruta absoluta del proyecto
     const projectRoot = path.resolve(process.cwd(), projectName);
     // 2. Evitar sobrescribir carpetas existentes
@@ -18,30 +19,29 @@ export async function createMonorepo({ projectName, webTemplate, apiTemplate, in
     // 4. Crear archivos de configuración del monorepo
     await createMonorepoConfig(projectRoot, projectName);
     // 5. Copiar template de frontend a apps/web
-    const webPath = path.join(projectRoot, 'apps', 'web');
     const webTemplatePath = getTemplatePath('frontend', webTemplate);
     if (await fs.pathExists(webTemplatePath)) {
-        await copyTemplate(webTemplatePath, webPath, {
+        await copyTemplate(webTemplatePath, path.join(projectRoot, 'apps', 'web'), {
             projectName: `${projectName}-web`,
         });
-        if (includeVitest) {
-            await injectVitest(webPath, 'frontend', webTemplate);
-        }
     }
     // 6. Copiar template de backend a apps/api
-    const apiPath = path.join(projectRoot, 'apps', 'api');
     const apiTemplatePath = getTemplatePath('backend', apiTemplate);
     if (await fs.pathExists(apiTemplatePath)) {
-        await copyTemplate(apiTemplatePath, apiPath, {
+        await copyTemplate(apiTemplatePath, path.join(projectRoot, 'apps', 'api'), {
             projectName: `${projectName}-api`,
         });
-        if (includeVitest) {
-            await injectVitest(apiPath, 'backend', apiTemplate);
-        }
     }
     // 7. Crear package shared básico
     await createSharedPackage(projectRoot, projectName);
-    // 8. Inicializar Git (si aplica)
+    // 8. Configurar Vitest en apps (si aplica)
+    if (useVitest) {
+        await setupVitest(path.join(projectRoot, 'apps', 'web'));
+        await setupVitest(path.join(projectRoot, 'apps', 'api'));
+    }
+    // 9. Instalar dependencias
+    installDependencies(projectRoot, packageManager);
+    // 10. Inicializar Git (si aplica)
     if (initGit) {
         initGitRepo(projectRoot);
     }

package/dist/generators/createProject.js

@@ -3,8 +3,9 @@ import path from 'node:path';
 import { getTemplatePath } from '../utils/getTemplatePath.js';
 import { copyTemplate } from '../utils/copyTemplate.js';
 import { initGitRepo } from '../utils/git.js';
-import { injectVitest } from '../utils/injectVitest.js';
-export async function createProject({ projectName, projectType, template, initGit, includeVitest, }) {
+import { setupVitest } from '../utils/setupVitest.js';
+import { installDependencies } from '../utils/installDependencies.js';
+export async function createProject({ projectName, projectType, template, initGit, useVitest, packageManager, }) {
     // 1. Resolver ruta absoluta del proyecto
     const projectRoot = path.resolve(process.cwd(), projectName);
     // 2. Evitar sobrescribir carpetas existentes
@@ -22,11 +23,13 @@ export async function createProject({ projectName, projectType, template, initGi
     await copyTemplate(templatePath, projectRoot, {
         projectName,
     });
-    // 6. Inyectar Vitest (si aplica)
-    if (includeVitest) {
-        await injectVitest(projectRoot, projectType, template);
+    // 6. Configurar Vitest (si aplica)
+    if (useVitest) {
+        await setupVitest(projectRoot);
     }
-    // 7. Inicializar Git (si aplica)
+    // 7. Instalar dependencias
+    installDependencies(projectRoot, packageManager);
+    // 8. Inicializar Git (si aplica)
     if (initGit) {
         initGitRepo(projectRoot);
     }

package/dist/prompts/initPrompts.js

@@ -56,14 +56,6 @@ export async function askInitQuestions(options = {}) {
             initial: true,
         });
     }
-    if (!options.skipVitest) {
-        questions.push({
-            type: 'confirm',
-            name: 'includeVitest',
-            message: 'Include Vitest for testing?',
-            initial: true,
-        });
-    }
     return prompts(questions, { onCancel });
 }
 export async function askTemplate(options) {
@@ -88,11 +80,11 @@ export async function askInitGit() {
         initial: true,
     }, { onCancel });
 }
-export async function askIncludeVitest() {
+export async function askUseVitest() {
     return prompts({
         type: 'confirm',
-        name: 'includeVitest',
-        message: 'Include Vitest for testing?',
-        initial: true,
+        name: 'useVitest',
+        message: 'Add Vitest for testing?',
+        initial: false,
     }, { onCancel });
 }

package/dist/types/project.js

@@ -2,5 +2,5 @@ export const DEFAULT_INIT_OPTIONS = {
     projectStructure: 'basic',
     projectType: 'frontend',
     initGit: true,
-    includeVitest: true,
+    useVitest: false,
 };

package/dist/utils/installDependencies.js

@@ -0,0 +1,8 @@
+import { execSync } from 'node:child_process';
+export function installDependencies(projectRoot, packageManager) {
+    const command = packageManager === 'yarn' ? 'yarn' : `${packageManager} install`;
+    execSync(command, {
+        cwd: projectRoot,
+        stdio: 'inherit',
+    });
+}

package/dist/utils/printDryRun.js

@@ -12,8 +12,7 @@ export function printDryRun(context) {
     else {
         printBasicPlan(context);
     }
-    console.log(`${styles.info('- Git:')} ${context.initGit ? 'would initialize' : 'skipped'}`);
-    console.log(`${styles.info('- Vitest:')} ${context.includeVitest ? 'would add' : 'skipped'}\n`);
+    console.log(`${styles.info('- Git:')} ${context.initGit ? 'would initialize' : 'skipped'}\n`);
     console.log(styles.title('Next steps'));
     console.log(`  ${styles.highlight(`cd ${context.projectName}`)}`);
     console.log(`  ${styles.highlight(`${context.packageManager} install`)}`);

package/dist/utils/printSummary.js

@@ -11,11 +11,9 @@ export function printSummary(context) {
         console.log(`${styles.info('- Template:')} ${context.projectType}/${context.template}`);
     }
     console.log(`${styles.info('- Directory:')} ./${context.projectName}`);
-    console.log(`${styles.info('- Git:')} ${context.initGit ? styles.success('initialized') : styles.muted('not initialized')}`);
-    console.log(`${styles.info('- Vitest:')} ${context.includeVitest ? styles.success('added') : styles.muted('not included')}\n`);
+    console.log(`${styles.info('- Git:')} ${context.initGit ? styles.success('initialized') : styles.muted('not initialized')}\n`);
     console.log(styles.title('Next steps'));
     console.log(`  ${styles.highlight(`cd ${context.projectName}`)}`);
-    console.log(`  ${styles.highlight(`${context.packageManager} install`)}`);
     console.log(`  ${styles.highlight(`${context.packageManager} run dev`)}`);
     console.log('');
 }

package/dist/utils/setupVitest.js

@@ -0,0 +1,31 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+const VITEST_CONFIG = `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});
+`;
+export async function setupVitest(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    // Leer package.json existente
+    const packageJson = await fs.readJson(packageJsonPath);
+    // Añadir devDependencies
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        vitest: '^3.0.0',
+    };
+    // Añadir scripts de test
+    packageJson.scripts = {
+        ...packageJson.scripts,
+        test: 'vitest',
+        'test:run': 'vitest run',
+    };
+    // Escribir package.json actualizado
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    // Crear vitest.config.ts
+    await fs.writeFile(path.join(projectRoot, 'vitest.config.ts'), VITEST_CONFIG);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devstarter-tool",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "description": "CLI to generate projects with best practices (basic or monorepo)",
   "author": "abraham-diaz",
@@ -22,7 +22,9 @@
     "backend",
     "boilerplate",
     "starter",
-    "devstarter"
+    "devstarter",
+    "vitest",
+    "testing"
   ],
   "engines": {
     "node": ">=18.0.0"

package/dist/utils/injectVitest.js

@@ -1,68 +0,0 @@
-import fs from 'fs-extra';
-import path from 'node:path';
-const VITEST_CONFIG = `import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-  },
-});
-`;
-const VITEST_CONFIG_REACT = `import { defineConfig } from 'vitest/config';
-import react from '@vitejs/plugin-react';
-
-export default defineConfig({
-  plugins: [react()],
-  test: {
-    globals: true,
-    environment: 'jsdom',
-  },
-});
-`;
-function getExampleTest(projectType, template) {
-    if (projectType === 'frontend' && template === 'react') {
-        return `import { describe, it, expect } from 'vitest';
-
-describe('Example test', () => {
-  it('should pass', () => {
-    expect(1 + 1).toBe(2);
-  });
-});
-`;
-    }
-    return `import { describe, it, expect } from 'vitest';
-
-describe('Example test', () => {
-  it('should pass', () => {
-    expect(1 + 1).toBe(2);
-  });
-});
-`;
-}
-export async function injectVitest(projectRoot, projectType, template) {
-    // 1. Modificar package.json
-    const packageJsonPath = path.join(projectRoot, 'package.json');
-    const packageJson = await fs.readJson(packageJsonPath);
-    // Agregar script test
-    packageJson.scripts = packageJson.scripts || {};
-    packageJson.scripts.test = 'vitest';
-    // Agregar devDependencies
-    packageJson.devDependencies = packageJson.devDependencies || {};
-    packageJson.devDependencies.vitest = '^3.1.4';
-    // Para React, agregar jsdom
-    if (projectType === 'frontend' && template === 'react') {
-        packageJson.devDependencies.jsdom = '^26.1.0';
-    }
-    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-    // 2. Crear vitest.config.ts
-    const vitestConfigPath = path.join(projectRoot, 'vitest.config.ts');
-    const configContent = projectType === 'frontend' && template === 'react'
-        ? VITEST_CONFIG_REACT
-        : VITEST_CONFIG;
-    await fs.writeFile(vitestConfigPath, configContent);
-    // 3. Crear test de ejemplo
-    const testDir = path.join(projectRoot, 'src', '__tests__');
-    await fs.ensureDir(testDir);
-    const testFilePath = path.join(testDir, 'example.test.ts');
-    await fs.writeFile(testFilePath, getExampleTest(projectType, template));
-}