devstarter-tool 0.1.0 → 0.2.0

package/README.md

@@ -1,126 +1,146 @@
-# devStarter CLI
+# devstarter-tool
 
-CLI para generar proyectos con buenas prácticas y configuraciones predefinidas.
+CLI to generate projects with best practices and predefined configurations.
 
-## Instalacion
+## Installation
 
 ```bash
-npm install -g devstarter-cli
+npm install -g devstarter-tool
 ```
 
-O ejecutar directamente con npx:
+Or run directly with npx:
 
 ```bash
-npx devstarter-cli init my-app
+npx devstarter-tool init my-app
 ```
 
-## Uso
+## Usage
 
-### Comando basico
+### Basic command
 
 ```bash
-devstarter init [nombre-proyecto]
+devstarter init [project-name]
 ```
 
-### Opciones
+### Options
 
-| Opcion | Descripcion |
+| Option | Description |
 |--------|-------------|
-| `-y, --yes` | Usar valores por defecto sin preguntar |
-| `-t, --type <tipo>` | Tipo de proyecto: `frontend` o `backend` |
-| `--dry-run` | Previsualizar cambios sin crear archivos |
+| `-y, --yes` | Use default values without prompting |
+| `-t, --type <type>` | Project type: `frontend` or `backend` |
+| `--template <name>` | Template to use |
+| `--dry-run` | Preview changes without creating files |
 
-### Ejemplos
+### Examples
 
 ```bash
-# Modo interactivo completo
+# Full interactive mode
 devstarter init
 
-# Crear proyecto con nombre especifico
+# Create project with specific name
 devstarter init my-app
 
-# Crear proyecto frontend sin preguntas
+# Create frontend project without prompts
 devstarter init my-app --type frontend -y
 
-# Previsualizar que archivos se crearian
+# Preview what files would be created
 devstarter init my-app --type frontend --dry-run
 ```
 
-## Templates disponibles
+## Project Structures
+
+### Basic (single project)
+
+```
+my-app/
+├── src/
+│   └── main.ts (or main.tsx for React)
+├── package.json
+├── README.md
+└── .git/ (if git is initialized)
+```
+
+### Monorepo (full-stack)
+
+```
+my-app/
+├── apps/
+│   ├── web/        <- frontend template
+│   └── api/        <- backend template
+├── packages/
+│   └── shared/     <- shared code
+├── package.json
+├── pnpm-workspace.yaml
+├── tsconfig.base.json
+└── README.md
+```
+
+## Available Templates
 
 ### Frontend
 
-| Template | Descripcion |
+| Template | Description |
 |----------|-------------|
-| `basic` | TypeScript minimal con estructura basica |
+| `basic` | Minimal TypeScript with basic structure |
 | `react` | React 18 + Vite + TypeScript |
 
 ### Backend
 
-| Template | Descripcion |
+| Template | Description |
 |----------|-------------|
 | `basic` | Express + TypeScript |
 
-## Estructura de proyecto generado
-
-```
-my-app/
-├── src/
-│   └── main.ts (o main.tsx para React)
-├── package.json
-├── README.md
-└── .git/ (si se inicializa git)
-```
-
-## Caracteristicas
+## Features
 
-- Deteccion automatica del package manager (npm, pnpm, yarn)
-- Seleccion interactiva de templates
-- Inicializacion de repositorio Git opcional
-- Modo dry-run para previsualizar cambios
-- Normalizacion automatica de nombres de proyecto (kebab-case)
-- Output con colores para mejor legibilidad
+- 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
 
-## Desarrollo
+## Development
 
-### Requisitos
+### Requirements
 
 - Node.js 18+
-- npm, pnpm o yarn
+- npm, pnpm or yarn
 
 ### Setup
 
 ```bash
-# Clonar repositorio
-git clone https://github.com/abraham-diaz/devStarter-cli.git
-cd devStarter-cli
+# Clone repository
+git clone https://github.com/abraham-diaz/devstarter-cli.git
+cd devstarter-cli
 
-# Instalar dependencias
+# Install dependencies
 npm install
 
-# Compilar
+# Build
 npm run build
 
-# Ejecutar localmente
+# Run locally
 node dist/cli.js init test-app --dry-run
 ```
 
-### Scripts disponibles
+### Available Scripts
 
-| Script | Descripcion |
+| Script | Description |
 |--------|-------------|
-| `npm run build` | Compila TypeScript y copia templates |
-| `npm run dev` | Modo watch para desarrollo |
-| `npm run lint` | Ejecuta ESLint |
-| `npm run format` | Formatea codigo con Prettier |
+| `npm run build` | Compile TypeScript and copy templates |
+| `npm run dev` | Watch mode for development |
+| `npm run test` | Run tests |
+| `npm run lint` | Run ESLint |
+| `npm run format` | Format code with Prettier |
 
-### Agregar nuevos templates
+### Adding New Templates
 
-1. Crear carpeta en `src/templates/<tipo>/<nombre-template>/`
-2. Agregar archivos del template (usar `.tpl` para archivos con placeholders)
-3. Placeholders disponibles: `{{projectName}}`
-4. Ejecutar `npm run build`
+1. Create folder in `src/templates/<type>/<template-name>/`
+2. Add template files (use `.tpl` extension for files with placeholders)
+3. Available placeholders: `{{projectName}}`
+4. Run `npm run build`
 
-## Licencia
+## License
 
 MIT

package/dist/cli.js

@@ -13,5 +13,7 @@ program
     .option('-t, --type <type>', 'Project type (frontend | backend)')
     .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')
     .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, } from '../../prompts/initPrompts.js';
+import { askProjectName, askProjectStructure, askInitQuestions, askTemplate, askInitGit, askIncludeVitest, } from '../../prompts/initPrompts.js';
 import { normalizeProjectName } from '../../utils/normalize.js';
 import { detectPackageManager } from '../../utils/detectPackageManager.js';
 import { listTemplates } from '../../utils/listTemplate.js';
@@ -39,20 +39,27 @@ async function collectStructure(useDefaults) {
 }
 async function collectBasicContext(projectName, options, useDefaults) {
     const typeFromFlag = resolveProjectType(options.type);
-    // Obtener tipo de proyecto e initGit
+    const gitFlagProvided = options.git !== undefined;
+    const vitestFlagProvided = options.vitest !== undefined;
+    // Obtener tipo de proyecto, initGit e includeVitest
     let projectType;
     let initGit;
+    let includeVitest;
     if (useDefaults) {
         projectType = typeFromFlag ?? DEFAULT_INIT_OPTIONS.projectType;
-        initGit = DEFAULT_INIT_OPTIONS.initGit;
+        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 = answers.initGit;
+        initGit = gitFlagProvided ? options.git : answers.initGit;
+        includeVitest = vitestFlagProvided ? options.vitest : answers.includeVitest;
     }
     // Obtener template
     const templates = listTemplates(projectType);
@@ -64,6 +71,7 @@ async function collectBasicContext(projectName, options, useDefaults) {
         projectType,
         template,
         initGit,
+        includeVitest,
         packageManager: detectPackageManager(),
         isDryRun: Boolean(options.dryRun),
     };
@@ -72,13 +80,17 @@ async function collectMonorepoContext(projectName, useDefaults, options) {
     // Templates para web (frontend) y api (backend)
     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 = DEFAULT_INIT_OPTIONS.initGit;
+        initGit = gitFlagProvided ? options.git : DEFAULT_INIT_OPTIONS.initGit;
+        includeVitest = vitestFlagProvided ? options.vitest : DEFAULT_INIT_OPTIONS.includeVitest;
     }
     else {
         const webAnswer = await askTemplate({
@@ -91,8 +103,20 @@ async function collectMonorepoContext(projectName, useDefaults, options) {
             message: 'Template for apps/api (backend):',
         });
         apiTemplate = apiAnswer.template;
-        const gitAnswer = await askInitGit();
-        initGit = gitAnswer.initGit;
+        if (gitFlagProvided) {
+            initGit = options.git;
+        }
+        else {
+            const gitAnswer = await askInitGit();
+            initGit = gitAnswer.initGit;
+        }
+        if (vitestFlagProvided) {
+            includeVitest = options.vitest;
+        }
+        else {
+            const vitestAnswer = await askIncludeVitest();
+            includeVitest = vitestAnswer.includeVitest;
+        }
     }
     return {
         structure: 'monorepo',
@@ -100,6 +124,7 @@ async function collectMonorepoContext(projectName, useDefaults, options) {
         webTemplate,
         apiTemplate,
         initGit,
+        includeVitest,
         packageManager: 'pnpm', // Monorepo usa pnpm por defecto
         isDryRun: Boolean(options.dryRun),
     };

package/dist/generators/createMonorepo.js

@@ -3,7 +3,8 @@ import path from 'node:path';
 import { getTemplatePath } from '../utils/getTemplatePath.js';
 import { copyTemplate } from '../utils/copyTemplate.js';
 import { initGitRepo } from '../utils/git.js';
-export async function createMonorepo({ projectName, webTemplate, apiTemplate, initGit, }) {
+import { injectVitest } from '../utils/injectVitest.js';
+export async function createMonorepo({ projectName, webTemplate, apiTemplate, initGit, includeVitest, }) {
     // 1. Resolver ruta absoluta del proyecto
     const projectRoot = path.resolve(process.cwd(), projectName);
     // 2. Evitar sobrescribir carpetas existentes
@@ -17,18 +18,26 @@ 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, path.join(projectRoot, 'apps', 'web'), {
+        await copyTemplate(webTemplatePath, webPath, {
             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, path.join(projectRoot, 'apps', 'api'), {
+        await copyTemplate(apiTemplatePath, apiPath, {
             projectName: `${projectName}-api`,
         });
+        if (includeVitest) {
+            await injectVitest(apiPath, 'backend', apiTemplate);
+        }
     }
     // 7. Crear package shared básico
     await createSharedPackage(projectRoot, projectName);

package/dist/generators/createProject.js

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

package/dist/prompts/initPrompts.js

@@ -48,12 +48,22 @@ export async function askInitQuestions(options = {}) {
             ],
         });
     }
-    questions.push({
-        type: 'confirm',
-        name: 'initGit',
-        message: 'Initialize a git repository?',
-        initial: true,
-    });
+    if (!options.skipInitGit) {
+        questions.push({
+            type: 'confirm',
+            name: 'initGit',
+            message: 'Initialize a git repository?',
+            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) {
@@ -78,3 +88,11 @@ export async function askInitGit() {
         initial: true,
     }, { onCancel });
 }
+export async function askIncludeVitest() {
+    return prompts({
+        type: 'confirm',
+        name: 'includeVitest',
+        message: 'Include Vitest for testing?',
+        initial: true,
+    }, { onCancel });
+}

package/dist/templates/frontend/basic/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{projectName}}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/dist/templates/frontend/basic/package.json.tpl

@@ -1,7 +1,14 @@
 {
   "name": "{{projectName}}",
   "private": true,
+  "type": "module",
   "scripts": {
-    "dev": "echo \"TODO\""
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4",
+    "vite": "^5.4.0"
   }
 }

package/dist/templates/frontend/basic/src/main.ts

@@ -1 +1,6 @@
-console.log('Hello from {{projectName}}');
+const app = document.querySelector<HTMLDivElement>('#app')!;
+
+app.innerHTML = `
+  <h1>{{projectName}}</h1>
+  <p>Edit <code>src/main.ts</code> and save to see HMR in action.</p>
+`;

package/dist/templates/frontend/basic/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ES2020"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "Bundler",
+    "strict": true
+  },
+  "include": ["src"]
+}

package/dist/types/project.js

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

package/dist/utils/injectVitest.js

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

package/dist/utils/printDryRun.js

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

package/package.json

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