devstarter-tool 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 abraham-diaz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,126 @@
+# devStarter CLI
+
+CLI para generar proyectos con buenas prácticas y configuraciones predefinidas.
+
+## Instalacion
+
+```bash
+npm install -g devstarter-cli
+```
+
+O ejecutar directamente con npx:
+
+```bash
+npx devstarter-cli init my-app
+```
+
+## Uso
+
+### Comando basico
+
+```bash
+devstarter init [nombre-proyecto]
+```
+
+### Opciones
+
+| Opcion | Descripcion |
+|--------|-------------|
+| `-y, --yes` | Usar valores por defecto sin preguntar |
+| `-t, --type <tipo>` | Tipo de proyecto: `frontend` o `backend` |
+| `--dry-run` | Previsualizar cambios sin crear archivos |
+
+### Ejemplos
+
+```bash
+# Modo interactivo completo
+devstarter init
+
+# Crear proyecto con nombre especifico
+devstarter init my-app
+
+# Crear proyecto frontend sin preguntas
+devstarter init my-app --type frontend -y
+
+# Previsualizar que archivos se crearian
+devstarter init my-app --type frontend --dry-run
+```
+
+## Templates disponibles
+
+### Frontend
+
+| Template | Descripcion |
+|----------|-------------|
+| `basic` | TypeScript minimal con estructura basica |
+| `react` | React 18 + Vite + TypeScript |
+
+### Backend
+
+| Template | Descripcion |
+|----------|-------------|
+| `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
+
+- 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
+
+## Desarrollo
+
+### Requisitos
+
+- Node.js 18+
+- npm, pnpm o yarn
+
+### Setup
+
+```bash
+# Clonar repositorio
+git clone https://github.com/abraham-diaz/devStarter-cli.git
+cd devStarter-cli
+
+# Instalar dependencias
+npm install
+
+# Compilar
+npm run build
+
+# Ejecutar localmente
+node dist/cli.js init test-app --dry-run
+```
+
+### Scripts disponibles
+
+| Script | Descripcion |
+|--------|-------------|
+| `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 |
+
+### Agregar nuevos 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`
+
+## Licencia
+
+MIT

package/dist/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+const program = new Command();
+program
+    .name('devstarter')
+    .description('CLI para generar proyectos con buenas prácticas')
+    .version('0.1.0');
+program
+    .command('init [projectName]')
+    .description('Inicializa un nuevo proyecto')
+    .option('-y, --yes', 'Use default options and skip prompts')
+    .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')
+    .action(initCommand);
+program.parse(process.argv);

package/dist/commands/init/collector.js

@@ -0,0 +1,113 @@
+import { DEFAULT_INIT_OPTIONS } from '../../types/project.js';
+import { askProjectName, askProjectStructure, askInitQuestions, askTemplate, askInitGit, } from '../../prompts/initPrompts.js';
+import { normalizeProjectName } from '../../utils/normalize.js';
+import { detectPackageManager } from '../../utils/detectPackageManager.js';
+import { listTemplates } from '../../utils/listTemplate.js';
+import { resolveProjectType, resolveTemplateFlag, resolveProjectName, resolveTemplateFinal, } from './resolvers.js';
+/**
+ * Recolecta todas las respuestas necesarias del usuario
+ * combinando flags, argumentos, defaults y prompts interactivos
+ */
+export async function collectInitContext(projectNameArg, options) {
+    const useDefaults = options.yes ?? false;
+    // Paso 1: Obtener nombre del proyecto
+    const projectName = await collectProjectName(projectNameArg, useDefaults);
+    // Paso 2: Obtener estructura (basic/monorepo)
+    const structure = await collectStructure(useDefaults);
+    // Paso 3: Bifurcar según estructura
+    if (structure === 'monorepo') {
+        return collectMonorepoContext(projectName, useDefaults, options);
+    }
+    return collectBasicContext(projectName, options, useDefaults);
+}
+async function collectProjectName(projectNameArg, useDefaults) {
+    if (projectNameArg) {
+        return normalizeProjectName(projectNameArg);
+    }
+    if (useDefaults) {
+        return normalizeProjectName(resolveProjectName(projectNameArg));
+    }
+    const answer = await askProjectName();
+    return normalizeProjectName(answer.projectName);
+}
+async function collectStructure(useDefaults) {
+    if (useDefaults) {
+        return DEFAULT_INIT_OPTIONS.projectStructure;
+    }
+    const answer = await askProjectStructure();
+    return answer.projectStructure;
+}
+async function collectBasicContext(projectName, options, useDefaults) {
+    const typeFromFlag = resolveProjectType(options.type);
+    // Obtener tipo de proyecto e initGit
+    let projectType;
+    let initGit;
+    if (useDefaults) {
+        projectType = typeFromFlag ?? DEFAULT_INIT_OPTIONS.projectType;
+        initGit = DEFAULT_INIT_OPTIONS.initGit;
+    }
+    else {
+        const answers = await askInitQuestions({
+            skipProjectName: true,
+            skipProjectType: Boolean(typeFromFlag),
+        });
+        projectType = typeFromFlag ?? answers.projectType;
+        initGit = answers.initGit;
+    }
+    // Obtener template
+    const templates = listTemplates(projectType);
+    const templateFromFlag = resolveTemplateFlag(options.template, templates);
+    const template = await collectTemplate(templateFromFlag, templates, useDefaults);
+    return {
+        structure: 'basic',
+        projectName,
+        projectType,
+        template,
+        initGit,
+        packageManager: detectPackageManager(),
+        isDryRun: Boolean(options.dryRun),
+    };
+}
+async function collectMonorepoContext(projectName, useDefaults, options) {
+    // Templates para web (frontend) y api (backend)
+    const frontendTemplates = listTemplates('frontend');
+    const backendTemplates = listTemplates('backend');
+    let webTemplate;
+    let apiTemplate;
+    let initGit;
+    if (useDefaults) {
+        webTemplate = frontendTemplates[0] ?? 'basic';
+        apiTemplate = backendTemplates[0] ?? 'basic';
+        initGit = DEFAULT_INIT_OPTIONS.initGit;
+    }
+    else {
+        const webAnswer = await askTemplate({
+            templates: frontendTemplates,
+            message: 'Template for apps/web (frontend):',
+        });
+        webTemplate = webAnswer.template;
+        const apiAnswer = await askTemplate({
+            templates: backendTemplates,
+            message: 'Template for apps/api (backend):',
+        });
+        apiTemplate = apiAnswer.template;
+        const gitAnswer = await askInitGit();
+        initGit = gitAnswer.initGit;
+    }
+    return {
+        structure: 'monorepo',
+        projectName,
+        webTemplate,
+        apiTemplate,
+        initGit,
+        packageManager: 'pnpm', // Monorepo usa pnpm por defecto
+        isDryRun: Boolean(options.dryRun),
+    };
+}
+async function collectTemplate(templateFlag, templates, useDefaults) {
+    const resolved = resolveTemplateFinal(templateFlag, templates, useDefaults);
+    if (resolved)
+        return resolved;
+    const answer = await askTemplate({ templates });
+    return answer.template;
+}

package/dist/commands/init/resolvers.js

@@ -0,0 +1,48 @@
+/**
+ * Valida y resuelve el flag --type a ProjectType
+ */
+export function resolveProjectType(optionType) {
+    if (!optionType)
+        return undefined;
+    if (optionType === 'frontend' || optionType === 'backend') {
+        return optionType;
+    }
+    throw new Error(`Invalid --type value "${optionType}". Use "frontend" or "backend".`);
+}
+/**
+ * Valida el flag --template contra templates disponibles
+ */
+export function resolveTemplateFlag(optionTemplate, available) {
+    if (!optionTemplate)
+        return undefined;
+    if (available.includes(optionTemplate))
+        return optionTemplate;
+    throw new Error(`Invalid --template "${optionTemplate}". Available: ${available.join(', ')}`);
+}
+/**
+ * Resuelve el nombre del proyecto con fallbacks
+ */
+export function resolveProjectName(argName, promptName) {
+    if (argName)
+        return argName;
+    if (promptName)
+        return promptName;
+    return process.cwd().split(/[\\/]/).pop() ?? 'my-app';
+}
+/**
+ * Determina el template final basado en múltiples fuentes
+ * Retorna undefined si necesita input del usuario
+ */
+export function resolveTemplateFinal(templateFlag, templates, useDefaults) {
+    // Prioridad 1: Flag explícito
+    if (templateFlag)
+        return templateFlag;
+    // Prioridad 2: Sin templates disponibles
+    if (templates.length === 0)
+        return 'basic';
+    // Prioridad 3: Modo defaults o único template
+    if (useDefaults || templates.length === 1)
+        return templates[0];
+    // Necesita input del usuario
+    return undefined;
+}

package/dist/commands/init.js

@@ -0,0 +1,38 @@
+import { PromptCancelledError } from '../prompts/initPrompts.js';
+import { createProject } from '../generators/createProject.js';
+import { createMonorepo } from '../generators/createMonorepo.js';
+import { printSummary } from '../utils/printSummary.js';
+import { printDryRun } from '../utils/printDryRun.js';
+import { styles } from '../utils/styles.js';
+import { collectInitContext } from './init/collector.js';
+/**
+ * Comando principal para inicializar un nuevo proyecto
+ * Orquesta recolección, validación y ejecución
+ */
+export async function initCommand(projectNameArg, options) {
+    try {
+        const context = await collectInitContext(projectNameArg, options);
+        if (context.isDryRun) {
+            printDryRun(context);
+            return;
+        }
+        if (context.structure === 'monorepo') {
+            await createMonorepo(context);
+        }
+        else {
+            await createProject(context);
+        }
+        printSummary(context);
+    }
+    catch (error) {
+        handleError(error);
+    }
+}
+function handleError(error) {
+    if (error instanceof PromptCancelledError) {
+        console.log(`\n${styles.muted('Operation cancelled')}`);
+        return;
+    }
+    console.error(`\n${styles.error('Error creating project:')}`);
+    console.error(styles.muted(error.message));
+}

package/dist/generators/createMonorepo.js

@@ -0,0 +1,142 @@
+import fs from 'fs-extra';
+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, }) {
+    // 1. Resolver ruta absoluta del proyecto
+    const projectRoot = path.resolve(process.cwd(), projectName);
+    // 2. Evitar sobrescribir carpetas existentes
+    if (await fs.pathExists(projectRoot)) {
+        throw new Error(`Directory "${projectName}" already exists`);
+    }
+    // 3. Crear estructura base del monorepo
+    await fs.ensureDir(projectRoot);
+    await fs.ensureDir(path.join(projectRoot, 'apps'));
+    await fs.ensureDir(path.join(projectRoot, 'packages'));
+    // 4. Crear archivos de configuración del monorepo
+    await createMonorepoConfig(projectRoot, projectName);
+    // 5. Copiar template de frontend a apps/web
+    const webTemplatePath = getTemplatePath('frontend', webTemplate);
+    if (await fs.pathExists(webTemplatePath)) {
+        await copyTemplate(webTemplatePath, path.join(projectRoot, 'apps', 'web'), {
+            projectName: `${projectName}-web`,
+        });
+    }
+    // 6. Copiar template de backend a apps/api
+    const apiTemplatePath = getTemplatePath('backend', apiTemplate);
+    if (await fs.pathExists(apiTemplatePath)) {
+        await copyTemplate(apiTemplatePath, path.join(projectRoot, 'apps', 'api'), {
+            projectName: `${projectName}-api`,
+        });
+    }
+    // 7. Crear package shared básico
+    await createSharedPackage(projectRoot, projectName);
+    // 8. Inicializar Git (si aplica)
+    if (initGit) {
+        initGitRepo(projectRoot);
+    }
+}
+async function createMonorepoConfig(projectRoot, projectName) {
+    // package.json raíz
+    const rootPackageJson = {
+        name: projectName,
+        private: true,
+        scripts: {
+            dev: 'pnpm -r dev',
+            build: 'pnpm -r build',
+            lint: 'pnpm -r lint',
+        },
+    };
+    await fs.writeJson(path.join(projectRoot, 'package.json'), rootPackageJson, {
+        spaces: 2,
+    });
+    // pnpm-workspace.yaml
+    const workspaceConfig = `packages:
+  - 'apps/*'
+  - 'packages/*'
+`;
+    await fs.writeFile(path.join(projectRoot, 'pnpm-workspace.yaml'), workspaceConfig);
+    // tsconfig.base.json
+    const tsconfigBase = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            declaration: true,
+            declarationMap: true,
+            composite: true,
+        },
+    };
+    await fs.writeJson(path.join(projectRoot, 'tsconfig.base.json'), tsconfigBase, {
+        spaces: 2,
+    });
+    // README.md
+    const readme = `# ${projectName}
+
+Monorepo project created with devstarter-cli.
+
+## Structure
+
+\`\`\`
+${projectName}/
+├─ apps/
+│  ├─ web/        ← frontend
+│  └─ api/        ← backend
+├─ packages/
+│  └─ shared/     ← shared code
+├─ package.json
+├─ pnpm-workspace.yaml
+└─ tsconfig.base.json
+\`\`\`
+
+## Getting Started
+
+\`\`\`bash
+pnpm install
+pnpm dev
+\`\`\`
+`;
+    await fs.writeFile(path.join(projectRoot, 'README.md'), readme);
+}
+async function createSharedPackage(projectRoot, projectName) {
+    const sharedDir = path.join(projectRoot, 'packages', 'shared');
+    await fs.ensureDir(path.join(sharedDir, 'src'));
+    // package.json para shared
+    const sharedPackageJson = {
+        name: `@${projectName}/shared`,
+        version: '0.0.1',
+        private: true,
+        type: 'module',
+        main: './src/index.ts',
+        types: './src/index.ts',
+        scripts: {
+            build: 'tsc',
+            dev: 'tsc --watch',
+        },
+    };
+    await fs.writeJson(path.join(sharedDir, 'package.json'), sharedPackageJson, {
+        spaces: 2,
+    });
+    // tsconfig.json para shared
+    const sharedTsconfig = {
+        extends: '../../tsconfig.base.json',
+        compilerOptions: {
+            outDir: './dist',
+            rootDir: './src',
+        },
+        include: ['src'],
+    };
+    await fs.writeJson(path.join(sharedDir, 'tsconfig.json'), sharedTsconfig, {
+        spaces: 2,
+    });
+    // index.ts básico
+    const indexContent = `// Shared utilities and types
+export {};
+`;
+    await fs.writeFile(path.join(sharedDir, 'src', 'index.ts'), indexContent);
+}

package/dist/generators/createProject.js

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+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, }) {
+    // 1. Resolver ruta absoluta del proyecto
+    const projectRoot = path.resolve(process.cwd(), projectName);
+    // 2. Evitar sobrescribir carpetas existentes
+    if (await fs.pathExists(projectRoot)) {
+        throw new Error(`Directory "${projectName}" already exists`);
+    }
+    // 3. Resolver el template a usar
+    const templatePath = getTemplatePath(projectType, template);
+    if (!(await fs.pathExists(templatePath))) {
+        throw new Error(`Template not found for type "${projectType}"`);
+    }
+    // 4. Crear carpeta raíz del proyecto
+    await fs.ensureDir(projectRoot);
+    // 5. Copiar template y reemplazar placeholders
+    await copyTemplate(templatePath, projectRoot, {
+        projectName,
+    });
+    // 6. Inicializar Git (si aplica)
+    if (initGit) {
+        initGitRepo(projectRoot);
+    }
+}

package/dist/prompts/initPrompts.js

@@ -0,0 +1,80 @@
+import prompts from 'prompts';
+export class PromptCancelledError extends Error {
+    constructor() {
+        super('Operation cancelled');
+        this.name = 'PromptCancelledError';
+    }
+}
+const onCancel = () => {
+    throw new PromptCancelledError();
+};
+export async function askProjectName() {
+    return prompts({
+        type: 'text',
+        name: 'projectName',
+        message: 'Project name:',
+        validate: (value) => value.length < 1 ? 'Project name is required' : true,
+    }, { onCancel });
+}
+export async function askProjectStructure() {
+    return prompts({
+        type: 'select',
+        name: 'projectStructure',
+        message: 'Project structure:',
+        choices: [
+            { title: 'Basic', value: 'basic', description: 'Single project (frontend or backend)' },
+            { title: 'Monorepo', value: 'monorepo', description: 'Full-stack with apps/web + apps/api' },
+        ],
+    }, { onCancel });
+}
+export async function askInitQuestions(options = {}) {
+    const questions = [];
+    if (!options.skipProjectName) {
+        questions.push({
+            type: 'text',
+            name: 'projectName',
+            message: 'Project name:',
+            validate: (value) => value.length < 1 ? 'Project name is required' : true,
+        });
+    }
+    if (!options.skipProjectType) {
+        questions.push({
+            type: 'select',
+            name: 'projectType',
+            message: 'Project type:',
+            choices: [
+                { title: 'Frontend', value: 'frontend' },
+                { title: 'Backend', value: 'backend' },
+            ],
+        });
+    }
+    questions.push({
+        type: 'confirm',
+        name: 'initGit',
+        message: 'Initialize a git repository?',
+        initial: true,
+    });
+    return prompts(questions, { onCancel });
+}
+export async function askTemplate(options) {
+    if (options.templates.length === 1) {
+        return { template: options.templates[0] };
+    }
+    return prompts({
+        type: 'select',
+        name: 'template',
+        message: options.message ?? 'Template:',
+        choices: options.templates.map((t) => ({
+            title: t,
+            value: t,
+        })),
+    }, { onCancel });
+}
+export async function askInitGit() {
+    return prompts({
+        type: 'confirm',
+        name: 'initGit',
+        message: 'Initialize a git repository?',
+        initial: true,
+    }, { onCancel });
+}

package/dist/templates/backend/basic/README.md.tpl

@@ -0,0 +1,7 @@
+# {{projectName}}
+
+Basic backend project generated with devstarter-cli.
+
+## Scripts
+
+- `npm run dev` – start the server

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

@@ -0,0 +1,15 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "express": "^4.19.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "tsx": "^4.15.7"
+  }
+}

package/dist/templates/backend/basic/src/index.ts

@@ -0,0 +1,12 @@
+import express, { Request, Response } from 'express';
+
+const app = express();
+const PORT = 3000;
+
+app.get('/', (_req: Request, res: Response) => {
+  res.json({ message: 'Hello from {{projectName}} backend' });
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/dist/templates/frontend/basic/README.md.tpl

@@ -0,0 +1,3 @@
+# {{projectName}}
+
+Generated with devstarter-cli

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

@@ -0,0 +1,7 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "scripts": {
+    "dev": "echo \"TODO\""
+  }
+}

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

@@ -0,0 +1 @@
+console.log('Hello from {{projectName}}');

package/dist/templates/frontend/react/README.md.tpl

@@ -0,0 +1,9 @@
+# {{projectName}}
+
+React project generated with devstarter-cli.
+
+## Scripts
+
+- `npm run dev`
+- `npm run build`
+- `npm run preview`

package/dist/templates/frontend/react/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="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

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

@@ -0,0 +1,21 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.1",
+    "typescript": "^5.5.4",
+    "vite": "^5.4.0"
+  }
+}

package/dist/templates/frontend/react/src/App.tsx

@@ -0,0 +1,8 @@
+export default function App() {
+  return (
+    <div style={{ padding: 24 }}>
+      <h1>Welcome to {{projectName}}</h1>
+      <p>Generated with devstarter-cli</p>
+    </div>
+  );
+}

package/dist/templates/frontend/react/src/main.tsx

@@ -0,0 +1,11 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+
+ReactDOM.createRoot(
+  document.getElementById('root')!,
+).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);

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

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

package/dist/templates/frontend/react/vite.config.ts

@@ -0,0 +1,6 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+});

package/dist/types/cli.js

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

package/dist/types/project.js

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

package/dist/utils/copyTemplate.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+export async function copyTemplate(templatePath, targetPath, vars) {
+    await fs.ensureDir(targetPath);
+    const entries = await fs.readdir(templatePath);
+    for (const entry of entries) {
+        const src = path.join(templatePath, entry);
+        const dest = path.join(targetPath, entry.replace('.tpl', ''));
+        const stat = await fs.stat(src);
+        if (stat.isDirectory()) {
+            await fs.ensureDir(dest);
+            await copyTemplate(src, dest, vars);
+        }
+        else {
+            let content = await fs.readFile(src, 'utf8');
+            for (const [key, value] of Object.entries(vars)) {
+                content = content.replaceAll(`{{${key}}}`, value);
+            }
+            await fs.writeFile(dest, content);
+        }
+    }
+}

package/dist/utils/copyTemplate.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'node:path';
+import os from 'node:os';
+import { copyTemplate } from './copyTemplate.js';
+describe('copyTemplate', () => {
+    let tempDir;
+    let templateDir;
+    let targetDir;
+    beforeEach(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'copy-template-test-'));
+        templateDir = path.join(tempDir, 'template');
+        targetDir = path.join(tempDir, 'target');
+        await fs.ensureDir(templateDir);
+        await fs.ensureDir(targetDir);
+    });
+    afterEach(async () => {
+        await fs.remove(tempDir);
+    });
+    it('should copy a simple file', async () => {
+        await fs.writeFile(path.join(templateDir, 'file.txt'), 'Hello World');
+        await copyTemplate(templateDir, targetDir, {});
+        const content = await fs.readFile(path.join(targetDir, 'file.txt'), 'utf8');
+        expect(content).toBe('Hello World');
+    });
+    it('should replace template variables', async () => {
+        await fs.writeFile(path.join(templateDir, 'package.json'), '{ "name": "{{projectName}}" }');
+        await copyTemplate(templateDir, targetDir, { projectName: 'my-app' });
+        const content = await fs.readFile(path.join(targetDir, 'package.json'), 'utf8');
+        expect(content).toBe('{ "name": "my-app" }');
+    });
+    it('should replace multiple occurrences of same variable', async () => {
+        await fs.writeFile(path.join(templateDir, 'readme.md'), '# {{projectName}}\n\nWelcome to {{projectName}}!');
+        await copyTemplate(templateDir, targetDir, { projectName: 'awesome-app' });
+        const content = await fs.readFile(path.join(targetDir, 'readme.md'), 'utf8');
+        expect(content).toBe('# awesome-app\n\nWelcome to awesome-app!');
+    });
+    it('should replace multiple different variables', async () => {
+        await fs.writeFile(path.join(templateDir, 'config.json'), '{ "name": "{{projectName}}", "author": "{{author}}" }');
+        await copyTemplate(templateDir, targetDir, {
+            projectName: 'my-app',
+            author: 'John Doe',
+        });
+        const content = await fs.readFile(path.join(targetDir, 'config.json'), 'utf8');
+        expect(content).toBe('{ "name": "my-app", "author": "John Doe" }');
+    });
+    it('should remove .tpl extension from files', async () => {
+        await fs.writeFile(path.join(templateDir, 'gitignore.tpl'), 'node_modules');
+        await copyTemplate(templateDir, targetDir, {});
+        expect(await fs.pathExists(path.join(targetDir, 'gitignore'))).toBe(true);
+        expect(await fs.pathExists(path.join(targetDir, 'gitignore.tpl'))).toBe(false);
+    });
+    it('should copy directories recursively', async () => {
+        const subDir = path.join(templateDir, 'src');
+        await fs.ensureDir(subDir);
+        await fs.writeFile(path.join(subDir, 'index.ts'), 'export default {}');
+        await copyTemplate(templateDir, targetDir, {});
+        const content = await fs.readFile(path.join(targetDir, 'src', 'index.ts'), 'utf8');
+        expect(content).toBe('export default {}');
+    });
+    it('should handle nested directories with variables', async () => {
+        const nestedDir = path.join(templateDir, 'src', 'components');
+        await fs.ensureDir(nestedDir);
+        await fs.writeFile(path.join(nestedDir, 'App.tsx'), 'const App = () => <div>{{projectName}}</div>');
+        await copyTemplate(templateDir, targetDir, { projectName: 'my-react-app' });
+        const content = await fs.readFile(path.join(targetDir, 'src', 'components', 'App.tsx'), 'utf8');
+        expect(content).toBe('const App = () => <div>my-react-app</div>');
+    });
+    it('should handle empty directories', async () => {
+        await fs.ensureDir(path.join(templateDir, 'empty-folder'));
+        await copyTemplate(templateDir, targetDir, {});
+        expect(await fs.pathExists(path.join(targetDir, 'empty-folder'))).toBe(true);
+    });
+});

package/dist/utils/detectPackageManager.js

@@ -0,0 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function detectPackageManager(cwd = process.cwd()) {
+    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) {
+        return 'pnpm';
+    }
+    if (fs.existsSync(path.join(cwd, 'yarn.lock'))) {
+        return 'yarn';
+    }
+    return 'npm';
+}

package/dist/utils/detectPackageManager.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'node:path';
+import os from 'node:os';
+import { detectPackageManager } from './detectPackageManager.js';
+describe('detectPackageManager', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'detect-pm-test-'));
+    });
+    afterEach(async () => {
+        await fs.remove(tempDir);
+    });
+    it('should detect pnpm when pnpm-lock.yaml exists', async () => {
+        await fs.writeFile(path.join(tempDir, 'pnpm-lock.yaml'), '');
+        expect(detectPackageManager(tempDir)).toBe('pnpm');
+    });
+    it('should detect yarn when yarn.lock exists', async () => {
+        await fs.writeFile(path.join(tempDir, 'yarn.lock'), '');
+        expect(detectPackageManager(tempDir)).toBe('yarn');
+    });
+    it('should default to npm when no lock file exists', async () => {
+        expect(detectPackageManager(tempDir)).toBe('npm');
+    });
+    it('should prioritize pnpm over yarn when both exist', async () => {
+        await fs.writeFile(path.join(tempDir, 'pnpm-lock.yaml'), '');
+        await fs.writeFile(path.join(tempDir, 'yarn.lock'), '');
+        expect(detectPackageManager(tempDir)).toBe('pnpm');
+    });
+    it('should detect npm when only package-lock.json exists', async () => {
+        await fs.writeFile(path.join(tempDir, 'package-lock.json'), '{}');
+        expect(detectPackageManager(tempDir)).toBe('npm');
+    });
+});

package/dist/utils/getTemplatePath.js

@@ -0,0 +1,7 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function getTemplatePath(projectType, template) {
+    return path.resolve(__dirname, '../../dist/templates', projectType, template);
+}

package/dist/utils/git.js

@@ -0,0 +1,29 @@
+import { execSync } from 'node:child_process';
+import fs from 'fs-extra';
+import path from 'node:path';
+export function initGitRepo(projectRoot) {
+    if (!fs.existsSync(projectRoot)) {
+        throw new Error('Project root does not exist');
+    }
+    // Evitar inicializar Git dentro de otro repo
+    if (fs.existsSync(path.join(projectRoot, '.git'))) {
+        throw new Error('Git repository already exists in project root');
+    }
+    try {
+        execSync('git init', {
+            cwd: projectRoot,
+            stdio: 'ignore',
+        });
+        execSync('git add .', {
+            cwd: projectRoot,
+            stdio: 'ignore',
+        });
+        execSync('git commit -m "Initial commit"', {
+            cwd: projectRoot,
+            stdio: 'ignore',
+        });
+    }
+    catch {
+        throw new Error('Failed to initialize git repository');
+    }
+}

package/dist/utils/listTemplate.js

@@ -0,0 +1,15 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function listTemplates(projectType) {
+    const base = path.resolve(__dirname, '../../dist/templates', projectType);
+    if (!fs.existsSync(base))
+        return [];
+    return fs
+        .readdirSync(base, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .sort();
+}

package/dist/utils/listTemplate.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { listTemplates } from './listTemplate.js';
+describe('listTemplates', () => {
+    it('should return array for frontend type', () => {
+        const templates = listTemplates('frontend');
+        expect(Array.isArray(templates)).toBe(true);
+    });
+    it('should return array for backend type', () => {
+        const templates = listTemplates('backend');
+        expect(Array.isArray(templates)).toBe(true);
+    });
+    it('should return sorted templates', () => {
+        const templates = listTemplates('frontend');
+        if (templates.length > 1) {
+            const sorted = [...templates].sort();
+            expect(templates).toEqual(sorted);
+        }
+    });
+    it('should include basic template for frontend if exists', () => {
+        const templates = listTemplates('frontend');
+        // Si hay templates, verificar que sean strings válidos
+        templates.forEach((template) => {
+            expect(typeof template).toBe('string');
+            expect(template.length).toBeGreaterThan(0);
+        });
+    });
+    it('should return empty array for non-existent project type directory', () => {
+        // Forzamos el tipo para probar el caso edge
+        const templates = listTemplates('nonexistent');
+        expect(templates).toEqual([]);
+    });
+});

package/dist/utils/listTemplateFiles.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function listTemplateFiles(templateDir, baseDir = '') {
+    const entries = fs.readdirSync(templateDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(templateDir, entry.name);
+        const relativePath = path.join(baseDir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listTemplateFiles(fullPath, relativePath));
+        }
+        else {
+            files.push(relativePath);
+        }
+    }
+    return files;
+}

package/dist/utils/normalize.js

@@ -0,0 +1,9 @@
+export function normalizeProjectName(input) {
+    return input
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .replace(/[^a-zA-Z0-9-]/g, '')
+        .replace(/-+/g, '-')
+        .toLowerCase();
+}

package/dist/utils/normalize.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeProjectName } from './normalize.js';
+describe('normalizeProjectName', () => {
+    it('should trim whitespace', () => {
+        expect(normalizeProjectName('  my-app  ')).toBe('my-app');
+    });
+    it('should convert camelCase to kebab-case', () => {
+        expect(normalizeProjectName('myApp')).toBe('my-app');
+        expect(normalizeProjectName('myAwesomeApp')).toBe('my-awesome-app');
+    });
+    it('should convert PascalCase to kebab-case', () => {
+        expect(normalizeProjectName('MyApp')).toBe('my-app');
+        expect(normalizeProjectName('MyAwesomeApp')).toBe('my-awesome-app');
+    });
+    it('should replace spaces with dashes', () => {
+        expect(normalizeProjectName('my app')).toBe('my-app');
+        expect(normalizeProjectName('my  awesome  app')).toBe('my-awesome-app');
+    });
+    it('should replace underscores with dashes', () => {
+        expect(normalizeProjectName('my_app')).toBe('my-app');
+        expect(normalizeProjectName('my__app')).toBe('my-app');
+    });
+    it('should remove invalid characters', () => {
+        expect(normalizeProjectName('my@app!')).toBe('myapp');
+        expect(normalizeProjectName('my$app#name')).toBe('myappname');
+    });
+    it('should collapse multiple dashes', () => {
+        expect(normalizeProjectName('my--app')).toBe('my-app');
+        expect(normalizeProjectName('my---awesome---app')).toBe('my-awesome-app');
+    });
+    it('should convert to lowercase', () => {
+        expect(normalizeProjectName('MY-APP')).toBe('my-app');
+        expect(normalizeProjectName('MyApp')).toBe('my-app');
+    });
+    it('should handle complex cases', () => {
+        expect(normalizeProjectName('  My_Awesome App! ')).toBe('my-awesome-app');
+        expect(normalizeProjectName('myApp_v2')).toBe('my-app-v2');
+    });
+    it('should handle empty string', () => {
+        expect(normalizeProjectName('')).toBe('');
+    });
+    it('should handle already normalized names', () => {
+        expect(normalizeProjectName('my-app')).toBe('my-app');
+        expect(normalizeProjectName('my-awesome-app')).toBe('my-awesome-app');
+    });
+});

package/dist/utils/printDryRun.js

@@ -0,0 +1,44 @@
+import { styles } from './styles.js';
+import { listTemplateFiles } from './listTemplateFiles.js';
+import { getTemplatePath } from './getTemplatePath.js';
+export function printDryRun(context) {
+    const baseDir = `./${context.projectName}`;
+    console.log(`\n${styles.warning('Dry run – no changes will be made')}\n`);
+    console.log(styles.title('Plan'));
+    console.log(`${styles.info('- Create directory:')} ${baseDir}`);
+    if (context.structure === 'monorepo') {
+        printMonorepoPlan(context);
+    }
+    else {
+        printBasicPlan(context);
+    }
+    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`)}`);
+    console.log(`  ${styles.highlight(`${context.packageManager} run dev`)}`);
+    console.log('');
+}
+function printBasicPlan(context) {
+    const templatePath = getTemplatePath(context.projectType, context.template);
+    const files = listTemplateFiles(templatePath);
+    console.log(`${styles.info('- Template:')} ${context.projectType}/${context.template}`);
+    console.log(styles.info('- Files:'));
+    files.forEach((file) => {
+        console.log(`  - ${file}`);
+    });
+}
+function printMonorepoPlan(context) {
+    console.log(`${styles.info('- Structure:')} monorepo`);
+    console.log(`${styles.info('- Web template:')} frontend/${context.webTemplate}`);
+    console.log(`${styles.info('- API template:')} backend/${context.apiTemplate}`);
+    console.log(styles.info('- Structure:'));
+    console.log('  - apps/');
+    console.log('    - web/ (frontend)');
+    console.log('    - api/ (backend)');
+    console.log('  - packages/');
+    console.log('    - shared/');
+    console.log('  - package.json');
+    console.log('  - pnpm-workspace.yaml');
+    console.log('  - tsconfig.base.json');
+}

package/dist/utils/printSummary.js

@@ -0,0 +1,20 @@
+import { styles } from './styles.js';
+export function printSummary(context) {
+    console.log(`\n${styles.success('✔ Project created successfully')}\n`);
+    console.log(styles.title('Summary'));
+    if (context.structure === 'monorepo') {
+        console.log(`${styles.info('- Structure:')} monorepo`);
+        console.log(`${styles.info('- Web template:')} frontend/${context.webTemplate}`);
+        console.log(`${styles.info('- API template:')} backend/${context.apiTemplate}`);
+    }
+    else {
+        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.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/styles.js

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+export const styles = {
+    title: chalk.bold,
+    success: chalk.green,
+    info: chalk.cyan,
+    warning: chalk.yellow,
+    error: chalk.red,
+    muted: chalk.gray,
+    highlight: chalk.bold.cyan,
+};

package/dist/utils/templates.js

@@ -0,0 +1,7 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function getTemplatePath(projectType, templateName = 'basic') {
+    return path.resolve(__dirname, '..', 'templates', projectType, templateName);
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "devstarter-tool",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI to generate projects with best practices (basic or monorepo)",
+  "author": "abraham-diaz",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abraham-diaz/devstarter-cli.git"
+  },
+  "homepage": "https://github.com/abraham-diaz/devstarter-cli#readme",
+  "bugs": {
+    "url": "https://github.com/abraham-diaz/devstarter-cli/issues"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "generator",
+    "monorepo",
+    "frontend",
+    "backend",
+    "boilerplate",
+    "starter",
+    "devstarter"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "devstarter": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc && node scripts/copyTemplates.mjs",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "prepare": "husky",
+    "prepublishOnly": "npm run build && npm run test:run"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/prompts": "^2.4.9",
+    "@typescript-eslint/eslint-plugin": "^8.50.1",
+    "@typescript-eslint/parser": "^8.50.1",
+    "chalk": "^5.6.2",
+    "eslint": "^9.39.2",
+    "husky": "^9.1.7",
+    "prettier": "^3.7.4",
+    "typescript": "5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "fs-extra": "^11.3.3",
+    "prompts": "^2.4.2"
+  }
+}