utn-cli 1.0.0

package/commands/backend.js

@@ -0,0 +1,282 @@
+import { limpiarDirectorioActual, copiarDirectorios, hacerPreguntaTrim, reemplazarContenidoEnArchivo, closeReadLine, mostrarVersion } from '../utils/index.js';
+import path from 'path';
+import fs from 'fs'; // Need fs here for renameSync
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function inicializarProyectoBackend() {
+  const rutaDelModuloJson = path.join(__dirname, '../../package.json'); // Main CLI's package.json
+  const informacionDeRutaDelModuloJson = JSON.parse(fs.readFileSync(rutaDelModuloJson, 'utf-8'));
+  console.log(`Versión de utn-backend (a través de utn-cli): ${informacionDeRutaDelModuloJson.version}.`);
+
+  const rutaDeMiscelaneas = path.join(process.cwd(), 'servicios/Nucleo/Miscelaneas.js');
+  reemplazarContenidoEnArchivo(rutaDeMiscelaneas, 'VERSION_DEL_NUCLEO', informacionDeRutaDelModuloJson.version);
+
+  const rutaDeInformacionDelModuloJson = path.join(process.cwd(), 'InformacionDelModulo.json');
+  // Check if InformacionDelModulo.json exists, if not, it's an init scenario.
+  if (!fs.existsSync(rutaDeInformacionDelModuloJson)) {
+      console.error('InformacionDelModulo.json not found. This should be present after copying templates.');
+      closeReadLine();
+      process.exit(1);
+  }
+  let informacionDelModuloJson = JSON.parse(fs.readFileSync(rutaDeInformacionDelModuloJson, 'utf-8'));
+  const rutaDeInformacionDelModulo = path.join(process.cwd(), 'servicios/InformacionDelModulo.js');
+
+  // Helper to ask and replace
+  async function askAndReplace(prop, promptText, fileToReplace, placeholder, specialHandler = null) {
+      let value = informacionDelModuloJson[prop];
+      if (value === placeholder) {
+          value = await hacerPreguntaTrim(promptText);
+          informacionDelModuloJson[prop] = value;
+      }
+      if (specialHandler) {
+          specialHandler(value);
+      }
+      reemplazarContenidoEnArchivo(fileToReplace, placeholder, value);
+      return value;
+  }
+
+  const NOMBRE_DEL_PROYECTO = await askAndReplace('NOMBRE_DEL_PROYECTO', '¿Cuál es el nombre del proyecto?: ', rutaDeInformacionDelModulo, 'NOMBRE_DEL_PROYECTO');
+  await askAndReplace('DESCRIPCION_DEL_PROYECTO', '¿Cuál es la descripción del proyecto?: ', rutaDeInformacionDelModulo, 'DESCRIPCION_DEL_PROYECTO');
+  await askAndReplace('DETALLE_DEL_PROYECTO', '¿Cuál es detalle del proyecto?: ', rutaDeInformacionDelModulo, 'DETALLE_DEL_PROYECTO');
+  
+  const NOMBRE_DEL_CANONICO_DEL_PROYECTO = await askAndReplace('NOMBRE_DEL_CANONICO_DEL_PROYECTO', '¿Cuál es el nombre canónico del proyecto?: ', rutaDeInformacionDelModulo, 'NOMBRE_DEL_CANONICO_DEL_PROYECTO', (val) => {
+      const oldFileName = path.join(process.cwd(), 'NOMBRE_DEL_CANONICO_DEL_PROYECTO.rest');
+      const newFileName = path.join(process.cwd(), `${val}.rest`);
+      if (fs.existsSync(oldFileName)) {
+          fs.renameSync(oldFileName, newFileName);
+      } else if (!fs.existsSync(newFileName)) {
+          // If the old file doesn't exist and the new one doesn't exist, it might be an update scenario where it was already renamed.
+          // Or a fresh init where the file might not be present always. Log for now.
+          console.log(`Warning: ${oldFileName} not found during canonical project name rename.`);
+      }
+  });
+
+  await askAndReplace('TIPO_DE_TARJETA', '¿Cuál es tipo de tarjeta? Posibles valores: Área, Proceso, Servicio: ', rutaDeInformacionDelModulo, 'TIPO_DE_TARJETA');
+  await askAndReplace('NOMBRE_DEL_ROL', '¿Cuál es el nombre del rol?: ', rutaDeInformacionDelModulo, 'NOMBRE_DEL_ROL');
+  
+  const NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS = await askAndReplace('NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', '¿Cuál es el nombre del repositorio de base de datos?: ', rutaDeInformacionDelModulo, 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', (val) => {
+      const rutaDeVariablesDeCalidad = path.join(process.cwd(), 'variables-calidad.env');
+      reemplazarContenidoEnArchivo(rutaDeVariablesDeCalidad, 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', val);
+      const rutaDeVariablesDeDesarrollo = path.join(process.cwd(), 'variables-desarrollo.env');
+      reemplazarContenidoEnArchivo(rutaDeVariablesDeDesarrollo, 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', val);
+      const rutaDeVariablesDePruebas = path.join(process.cwd(), 'variables-pruebas.env');
+      reemplazarContenidoEnArchivo(rutaDeVariablesDePruebas, 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', val);
+      const rutaDeDB = path.join(process.cwd(), 'servicios/Nucleo/db.js');
+      reemplazarContenidoEnArchivo(rutaDeDB, 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', val.slice(0, -3));
+  });
+
+  const NOMBRE_DEL_REPOSITORIO_DE_BACKEND = await askAndReplace('NOMBRE_DEL_REPOSITORIO_DE_BACKEND', '¿Cuál es el nombre del repositorio de backend?: ', rutaDeInformacionDelModulo, 'NOMBRE_DEL_REPOSITORIO_DE_BACKEND', (val) => {
+      const rutaPackage = path.join(process.cwd(), 'package.json');
+      reemplazarContenidoEnArchivo(rutaPackage, 'nombre_del_repositorio_backend', val);
+      const rutaDeserver = path.join(process.cwd(), 'server.js');
+      reemplazarContenidoEnArchivo(rutaDeserver, 'NOMBRE_DEL_REPOSITORIO_DE_BACKEND', `${val} corriendo en el puerto 80.`);
+  });
+
+  await askAndReplace('NOMBRE_DEL_REPOSITORIO_DE_FRONTEND', '¿Cuál es el nombre del repositorio de frontend?: ', rutaDeInformacionDelModulo, 'NOMBRE_DEL_REPOSITORIO_DE_FRONTEND');
+  await askAndReplace('NOMBRE_DEL_PERMISO', '¿Cuál es el nombre del permiso?: ', rutaDeInformacionDelModulo, 'NOMBRE_DEL_PERMISO');
+  await askAndReplace('DESCRIPCION_DEL_PERMISO', '¿Cuál es la descripción del permiso?: ', rutaDeInformacionDelModulo, 'DESCRIPCION_DEL_PERMISO');
+  await askAndReplace('MENU_PADRE', '¿Cuál es nombre canónico del menú padre?: ', rutaDeInformacionDelModulo, 'MENU_PADRE');
+  await askAndReplace('COLOR_DEL_MODULO', '¿Cuál es el color del módulo?: ', rutaDeInformacionDelModulo, 'COLOR_DEL_MODULO');
+  await askAndReplace('CORRECO_PARA_REPORTES', '¿Cuál es correo para reportes?: ', rutaDeInformacionDelModulo, 'CORRECO_PARA_REPORTES');
+  
+  const nombre_de_desarrollador = await askAndReplace('nombre_de_desarrollador', '¿Cuál es el nombre de desarrollador?: ', path.join(process.cwd(), 'package.json'), 'nombre_de_desarrollador', (val) => {
+      reemplazarContenidoEnArchivo(path.join(process.cwd(), 'package.json'), 'nombre_de_desarrollador', `Para la Universidad Técnica Nacional por: ${val}`);
+  });
+
+  await askAndReplace('CEDULA_DEL_DESARROLLADOR', '¿Cuál es el número de cédula del desarrollador?: ', rutaDeInformacionDelModulo, 'CEDULA_DEL_DESARROLLADOR');
+  
+  const url_del_grupo = await askAndReplace('url_del_grupo', '¿Cuál es el URL del grupo en el git?: ', path.join(process.cwd(), 'package.json'), 'url_del_grupo', (val) => {
+      reemplazarContenidoEnArchivo(path.join(process.cwd(), 'package.json'), 'url_del_grupo', val);
+  });
+
+  let BACKENDS_QUE_CONSUME_ESTE_MODULO = informacionDelModuloJson.BACKENDS_QUE_CONSUME_ESTE_MODULO;
+  if (BACKENDS_QUE_CONSUME_ESTE_MODULO === 'BACKENDS_QUE_CONSUME_ESTE_MODULO') {
+    BACKENDS_QUE_CONSUME_ESTE_MODULO = await hacerPreguntaTrim('¿Qué backends consume este módulo? Lista separada por coma: ');
+    if (BACKENDS_QUE_CONSUME_ESTE_MODULO.trim().length > 0) {
+      BACKENDS_QUE_CONSUME_ESTE_MODULO = BACKENDS_QUE_CONSUME_ESTE_MODULO.split(",").map((x) => "'" + x.trim() + "'").toString();
+    } else {
+      BACKENDS_QUE_CONSUME_ESTE_MODULO = "";
+    }
+    informacionDelModuloJson.BACKENDS_QUE_CONSUME_ESTE_MODULO = BACKENDS_QUE_CONSUME_ESTE_MODULO;
+  } else {
+    // Already set, but needs formatting for replacement if not empty
+    if (BACKENDS_QUE_CONSUME_ESTE_MODULO.trim().length > 0 && !BACKENDS_QUE_CONSUME_ESTE_MODULO.startsWith("'")) {
+        BACKENDS_QUE_CONSUME_ESTE_MODULO = BACKENDS_QUE_CONSUME_ESTE_MODULO.split(",").map((x) => "'" + x.trim() + "'").toString();
+    }
+  }
+  if (BACKENDS_QUE_CONSUME_ESTE_MODULO.trim().length > 2) {
+    reemplazarContenidoEnArchivo(rutaDeInformacionDelModulo, 'BACKENDS_QUE_CONSUME_ESTE_MODULO', BACKENDS_QUE_CONSUME_ESTE_MODULO);
+  } else {
+    reemplazarContenidoEnArchivo(rutaDeInformacionDelModulo, 'BACKENDS_QUE_CONSUME_ESTE_MODULO', '');
+  }
+
+  await askAndReplace('VERSION', '¿Cuál es versión del módulo?: ', rutaDeInformacionDelModulo, 'VERSION');
+
+  fs.writeFileSync(rutaDeInformacionDelModuloJson, JSON.stringify(informacionDelModuloJson, null, 2));
+}
+
+export async function initBackend() {
+  console.log('Limpiando directorio actual...');
+  limpiarDirectorioActual(['commit-message.txt']);
+  console.log('Inicializando el proyecto de backend...');
+  
+  const directoriodePlantillas = path.join(__dirname, '../../templates/backend');
+  const directorioDestino = process.cwd();
+
+  if (!fs.existsSync(directoriodePlantillas)) {
+    console.error(`La carpeta de plantillas de Backend no existe en: ${directoriodePlantillas}`);
+    closeReadLine();
+    process.exit(1);
+  }
+
+  copiarDirectorios(directoriodePlantillas, directorioDestino);
+  
+  // Specific renames for Backend
+  const gitignorePath = path.join(directorioDestino, 'gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    fs.renameSync(gitignorePath, path.join(directorioDestino, '.gitignore'));
+  }
+
+  await inicializarProyectoBackend();
+  console.log('Proyecto de backend inicializado exitosamente.');
+  closeReadLine();
+}
+
+export async function updateBackend() {
+  console.log('Actualizando el proyecto de backend...');
+  const archivosAExcluir = ['InformacionDelModulo.json', 'rutas.js', 'Monitoreo.js', 'API.js'];
+  const directoriodePlantillas = path.join(__dirname, '../../templates/backend');
+  const directorioDestino = process.cwd();
+
+  if (!fs.existsSync(directoriodePlantillas)) {
+    console.error(`La carpeta de plantillas de Backend no existe en: ${directoriodePlantillas}`);
+    closeReadLine();
+    process.exit(1);
+  }
+
+  copiarDirectorios(directoriodePlantillas, directorioDestino, archivosAExcluir);
+  mostrarVersion(path.join(__dirname, '../../package.json')); // Show main CLI version
+  console.log('Proyecto de backend actualizado exitosamente.');
+  closeReadLine();
+}
+
+export async function addServiceBackend() {
+  let Servicio = await hacerPreguntaTrim('¿Cuál es el nombre del servicio?: ');
+  Servicio = Servicio.replace(/\s/g, '');
+  const rutaServicioDir = path.join(process.cwd(), 'servicios');
+  const rutaRutaDir = path.join(process.cwd(), 'rutas');
+
+  // Copy template service files
+  const templateServicioPath = path.join(rutaServicioDir, 'Servicio1.js');
+  const newServicioPath = path.join(rutaServicioDir, Servicio + '.js');
+  if (fs.existsSync(templateServicioPath)) { // Ensure template exists
+      fs.copyFileSync(templateServicioPath, newServicioPath);
+  } else {
+      console.error(`Error: Template Servicio1.js not found in ${rutaServicioDir}`);
+      closeReadLine();
+      process.exit(1);
+  }
+
+  const templateRutaPath = path.join(rutaRutaDir, 'Servicio1.js');
+  const newRutaPath = path.join(rutaRutaDir, Servicio + '.js');
+  if (fs.existsSync(templateRutaPath)) { // Ensure template exists
+      fs.copyFileSync(templateRutaPath, newRutaPath);
+  } else {
+      console.error(`Error: Template Servicio1.js not found in ${rutaRutaDir}`);
+      closeReadLine();
+      process.exit(1);
+  }
+
+  // Update rutas.js
+  const rutaRutasJs = path.join(rutaRutaDir, 'rutas.js');
+  if (fs.existsSync(rutaRutasJs)) {
+    let contenidoRutasJs = fs.readFileSync(rutaRutasJs, 'utf-8');
+    const nuevaRutaRequire = `const rutasDel${Servicio} = require('./${Servicio}.js');`;
+    contenidoRutasJs = contenidoRutasJs.replace(/\s*function asignarRutasAExpress\(app\) {/, `
+${nuevaRutaRequire}
+
+function asignarRutasAExpress(app) {`);
+    contenidoRutasJs = contenidoRutasJs.replace(/app\.use\('\/Servicio1', rutasDelServicio1\);/, `app.use('/Servicio1', rutasDelServicio1);
+  app.use('/${Servicio}', rutasDel${Servicio});`);
+    fs.writeFileSync(rutaRutasJs, contenidoRutasJs);
+  } else {
+      console.error(`Error: rutas.js not found in ${rutaRutaDir}`);
+      closeReadLine();
+      process.exit(1);
+  }
+
+  reemplazarContenidoEnArchivo(newServicioPath, 'Servicio1', Servicio);
+  reemplazarContenidoEnArchivo(newRutaPath, 'Servicio1', Servicio);
+
+  // Cross-module interaction with Frontend - this needs a different approach in a unified CLI
+  // For now, I'll comment out the frontend-related logic as it breaks modularity and
+  // assumes frontend project structure relative to backend, which might not be true in a monorepo.
+  // This should be handled by a dedicated 'utn frontend add-service' command or similar.
+  /*
+  const rutaArchivoJson = path.join(process.cwd(), 'InformacionDelModulo.json');
+  const contenidoJson = fs.readFileSync(rutaArchivoJson, 'utf8');
+  const informacion = JSON.parse(contenidoJson);
+  const nombreDelFrontend = informacion.NOMBRE_DEL_REPOSITORIO_DE_FRONTEND;
+  const rutaDelFrontEnd = path.join(process.cwd(), '..', nombreDelFrontend, '/src/app/Paginas'); // This path is problematic
+  const servicioEnMinuscula = Servicio.toLowerCase();
+  const rutaOrigen = path.join(rutaDelFrontEnd, '/gestion-tabla');
+  const nombreCarpetaDestino = `/gestion-tabla-${servicioEnMinuscula}`;
+  const rutaDestino = path.join(rutaDelFrontEnd, nombreCarpetaDestino);
+  try {
+    fs.cpSync(rutaOrigen, rutaDestino, { recursive: true });
+  } catch (error) {
+    console.error('Hubo un error al copiar la carpeta:', error);
+  }
+  const archivos = fs.readdirSync(rutaDestino);
+  archivos.forEach(archivo => {
+    if (archivo.startsWith('gestion-tabla.component')) {
+      const nuevoNombre = archivo.replace('gestion-tabla', `gestion-tabla-${servicioEnMinuscula}`);
+      const rutaArchivoViejo = path.join(rutaDestino, archivo);
+      const rutaArchivoNuevo = path.join(rutaDestino, nuevoNombre);
+      fs.renameSync(rutaArchivoViejo, rutaArchivoNuevo);
+    }
+  });
+  const rutaArchivoTs = path.join(rutaDestino, `/gestion-tabla-${servicioEnMinuscula}.component.ts`);
+  let contenidoTs = fs.readFileSync(rutaArchivoTs, 'utf8');
+  contenidoTs = contenidoTs.replace(
+    /gestion-tabla\.component/g,
+    `gestion-tabla-${servicioEnMinuscula}.component`
+  );
+  const servicioCapitalizado = Servicio.charAt(0).toUpperCase() + Servicio.slice(1);
+  contenidoTs = contenidoTs.replace(
+    /export class GestionTablaComponent/,
+    `export class GestionTabla${servicioCapitalizado}Component`
+  );
+  fs.writeFileSync(rutaArchivoTs, contenidoTs, 'utf8');
+  const rutaAppRoutes = path.join(rutaDelFrontEnd, '../app.routes.ts');
+  const nombreComponente = `GestionTabla${servicioCapitalizado}Component`;
+  const rutaComponente = `./Paginas/gestion-tabla-${servicioEnMinuscula}/gestion-tabla-${servicioEnMinuscula}.component`;
+  const nuevaLineaImport = `import { ${nombreComponente} } from '${rutaComponente}';`;
+  const nuevaLineaRuta = `,
+  { path: '${servicioEnMinuscula}', component: ${nombreComponente} }`;
+  let contenidoRoutes = fs.readFileSync(rutaAppRoutes, 'utf8');
+  contenidoRoutes = contenidoRoutes.replace(
+    /\s*export const routes: Routes = \[/,
+    `
+${nuevaLineaImport}
+
+export const routes: Routes = [`
+  );
+  contenidoRoutes = contenidoRoutes.replace(
+    /\s*];/,
+    `${nuevaLineaRuta}
+];`
+  );
+  fs.writeFileSync(rutaAppRoutes, contenidoRoutes, 'utf8');
+  */
+
+  console.log(`Servicio ${Servicio} agregado exitosamente.`);
+  closeReadLine();
+}
+
+export function showBackendVersion() {
+  mostrarVersion(path.join(__dirname, '../../package.json'));
+  closeReadLine();
+}

package/commands/db.js

@@ -0,0 +1,49 @@
+import { limpiarDirectorioActual, copiarDirectorios, hacerPregunta, reemplazarContenidoEnArchivo, closeReadLine, mostrarVersion } from '../utils/index.js';
+import path from 'path';
+import fs from 'fs'; // Import fs here
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function initDb() {
+  console.log('Limpiando directorio actual...');
+  limpiarDirectorioActual(['commit-message.txt']); // Assuming this is still relevant for DB
+  console.log('Inicializando el proyecto de base de datos...');
+
+  const directoriodePlantillas = path.join(__dirname, '../../templates/bd');
+  const directorioDestino = process.cwd();
+
+  if (!fs.existsSync(directoriodePlantillas)) {
+    console.error(`La carpeta de plantillas de DB no existe en: ${directoriodePlantillas}`);
+    closeReadLine();
+    process.exit(1);
+  }
+  
+  copiarDirectorios(directoriodePlantillas, directorioDestino);
+  
+  // Specific renames for DB
+  // This needs to be handled carefully, as original was 'cumulodb-scripts/gitignore' to 'cumulodb-scripts/.gitignore'
+  // and now templates are nested.
+  // For now, assume these renames are hardcoded for the template structure.
+  const gitignorePath = path.join(directorioDestino, 'cumulodb-scripts/gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    fs.renameSync(gitignorePath, path.join(directorioDestino, 'cumulodb-scripts/.gitignore'));
+  }
+
+  // Initializing project (asking for repo name and replacing)
+  const rutaCompose = path.join(process.cwd(), 'docker-compose.yml');
+  const rutaCrearEstructuras = path.join(process.cwd(), 'docker-scripts/1-crear estructura.sql');
+
+  const repositorioDeBaseDeDatos = await hacerPregunta('¿Cuál es el nombre del repositorio de base de datos?: ');
+  reemplazarContenidoEnArchivo(rutaCompose, 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', repositorioDeBaseDeDatos);
+  reemplazarContenidoEnArchivo(rutaCrearEstructuras, 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS', repositorioDeBaseDeDatos.slice(0, -3)); // Assuming .slice(0,-3) is to remove 'DB' or similar suffix
+
+  console.log('Proyecto de base de datos inicializado exitosamente.');
+  closeReadLine();
+}
+
+export function showDbVersion() {
+  // Assuming the version for 'db' command comes from the main utn-cli package.json
+  mostrarVersion(path.join(__dirname, '../../package.json'));
+  closeReadLine();
+}

package/commands/frontend.js

@@ -0,0 +1,225 @@
+import { limpiarDirectorioActual, copiarDirectorios, hacerPreguntaTrim, reemplazarContenidoEnArchivo, closeReadLine, mostrarVersion } from '../utils/index.js';
+import path from 'path';
+import fs from 'fs';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function initFrontend() {
+  console.log('Limpiando directorio actual...');
+  limpiarDirectorioActual(['commit-message.txt']);
+  console.log('Inicializando el proyecto de frontend...');
+  
+  const directoriodePlantillas = path.join(__dirname, '../../templates/frontend');
+  const directorioDestino = process.cwd();
+
+  if (!fs.existsSync(directoriodePlantillas)) {
+    console.error(`La carpeta de plantillas de Frontend no existe en: ${directoriodePlantillas}`);
+    closeReadLine();
+    process.exit(1);
+  }
+
+  copiarDirectorios(directoriodePlantillas, directorioDestino);
+  
+  // Specific renames for Frontend
+  const gitignorePath = path.join(directorioDestino, 'gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    fs.renameSync(gitignorePath, path.join(directorioDestino, '.gitignore'));
+  }
+  const editorconfigPath = path.join(directorioDestino, 'editorconfig');
+  if (fs.existsSync(editorconfigPath)) {
+    fs.renameSync(editorconfigPath, path.join(directorioDestino, '.editorconfig'));
+  }
+  const vscodePath = path.join(directorioDestino, 'vscode');
+  if (fs.existsSync(vscodePath)) {
+    fs.renameSync(vscodePath, path.join(directorioDestino, '.vscode'));
+  }
+
+  console.log('Proyecto de frontend inicializado exitosamente.');
+  closeReadLine();
+}
+
+export async function updateFrontend() {
+  console.log('Actualizando el proyecto de frontend...');
+  const archivosAExcluir = ['app.routes.ts', 'contenedor-principal.component.css', 'contenedor-principal.component.html', 'contenedor-principal.component.ts', '.vscode', 'dist'];
+  const directoriodePlantillas = path.join(__dirname, '../../templates/frontend');
+  const directorioDestino = process.cwd();
+
+  if (!fs.existsSync(directoriodePlantillas)) {
+    console.error(`La carpeta de plantillas de Frontend no existe en: ${directoriodePlantillas}`);
+    closeReadLine();
+    process.exit(1);
+  }
+
+  copiarDirectorios(directoriodePlantillas, directorioDestino, archivosAExcluir);
+  mostrarVersion(path.join(__dirname, '../../package.json'));
+  console.log('Proyecto de frontend actualizado exitosamente.');
+  closeReadLine();
+}
+
+async function confirmarPaso(pregunta) {
+  const respuesta = await hacerPreguntaTrim(`${pregunta} (Sí/no) [Sí]: `);
+  const respuestaNormalizada = respuesta.trim().toLowerCase();
+  if (respuesta === '' || respuestaNormalizada === 'si' || respuestaNormalizada === 'sí' || respuestaNormalizada === 's') {
+    return true;
+  }
+  return false;
+}
+
+export async function commitFrontend() {
+  // Original commit logic, wrapped
+  if (!await confirmarPaso('¿Ya realizó la revisión ortográfica del proyecto?')) return closeReadLine();
+  if (!await confirmarPaso('¿Ya realizó el registro de los servicios?')) return closeReadLine();
+  if (!await confirmarPaso('¿Ya realizó la revisión con Gemini?')) return closeReadLine();
+  if (!await confirmarPaso('¿Todos los endpoints están en el archivo rest?')) return closeReadLine();
+  if (!await confirmarPaso('¿Ya realizó el build del frontend?')) return closeReadLine();
+  if (!await confirmarPaso('¿Ya realizó el update de los módulos de UTN?')) return closeReadLine();
+  if (!await confirmarPaso('¿Ya revisó la visualización en móvil?')) return closeReadLine();
+  if (!await confirmarPaso('¿Ya hizo el stage de todos los cambios?')) return closeReadLine();
+
+  try {
+    console.log('Ejecutando git commit...');
+    execSync('git commit -m "* NEW: Respaldo de código"', { stdio: 'inherit' });
+
+    console.log('Ejecutando git pull --rebase...');
+    execSync('git pull --rebase', { stdio: 'inherit' });
+
+    console.log('Ejecutando git push...');
+    execSync('git push', { stdio: 'inherit' });
+
+    console.log('Proceso de commit finalizado con éxito.');
+  } catch (error) {
+    console.error('Ocurrió un error al ejecutar los comandos de git.', error.message);
+  } finally {
+    closeReadLine();
+  }
+}
+
+export async function cloneFrontendComponent() {
+  const nombre = await hacerPreguntaTrim('Ingrese el nombre del nuevo componente (se reemplazará XYZ): ');
+  if (!nombre) {
+    console.error('El nombre es requerido.');
+    closeReadLine();
+    process.exit(1);
+  }
+  
+  const titulo = await hacerPreguntaTrim('Ingrese el título para la tarjeta: ');
+  const descripcion = await hacerPreguntaTrim('Ingrese la descripción para la tarjeta: ');
+
+  const nombreLower = nombre.toLowerCase();
+  const nombreCapitalizado = nombre.charAt(0).toUpperCase() + nombre.slice(1);
+  const nombreClase = `GestionTabla${nombreCapitalizado}Component`;
+  const nombreRuta = `gestion-tabla-${nombreLower}`;
+  
+  const rutaFuente = path.join(__dirname, '../../templates/frontend', 'src', 'app', 'Paginas', 'gestion-tabla-XYZ');
+  const rutaDestino = path.join(process.cwd(), 'src', 'app', 'Paginas', nombreRuta);
+
+  if (!fs.existsSync(rutaFuente)) {
+    console.error(`No se encontró la carpeta plantilla en: ${rutaFuente}`);
+    closeReadLine();
+    process.exit(1);
+  }
+
+  if (fs.existsSync(rutaDestino)) {
+    console.error(`La carpeta destino ya existe: ${rutaDestino}`);
+    closeReadLine();
+    process.exit(1);
+  }
+
+  console.log(`Clonando carpeta...`);
+
+  function copiarYReemplazar(fuente, destino) {
+    if (!fs.existsSync(destino)) {
+      fs.mkdirSync(destino, { recursive: true });
+    }
+    const entradas = fs.readdirSync(fuente, { withFileTypes: true });
+    entradas.forEach((entrada) => {
+        const nombreOriginal = entrada.name;
+        const nombreNuevo = nombreOriginal.replace(/XYZ/g, nombreLower);
+        const rutaFuente = path.join(fuente, nombreOriginal);
+        const rutaDestino = path.join(destino, nombreNuevo);
+
+        if (entrada.isDirectory()) {
+            copiarYReemplazar(rutaFuente, rutaDestino);
+        } else if (entrada.isFile()) {
+            let contenido = fs.readFileSync(rutaFuente, 'utf-8');
+            contenido = contenido.replace(/GestionTablaXYZComponent/g, nombreClase);
+            contenido = contenido.replace(/XYZ/g, nombreLower);
+            fs.writeFileSync(rutaDestino, contenido);
+        }
+    });
+  }
+
+  copiarYReemplazar(rutaFuente, rutaDestino);
+  console.log(`Componente creado en: ${rutaDestino}`);
+
+  // --- Modificar app.routes.ts ---
+  console.log('Actualizando app.routes.ts...');
+  const rutaRoutes = path.join(process.cwd(), 'src', 'app', 'app.routes.ts');
+  if (fs.existsSync(rutaRoutes)) {
+    let contenidoRoutes = fs.readFileSync(rutaRoutes, 'utf-8');
+    
+    const lineaImport = `import { ${nombreClase} } from './Paginas/${nombreRuta}/${nombreRuta}.component';`;
+    const ultimoImportIndex = contenidoRoutes.lastIndexOf('import {');
+    const finUltimoImport = contenidoRoutes.indexOf(';', ultimoImportIndex);
+    
+    if (finUltimoImport !== -1) {
+       contenidoRoutes = contenidoRoutes.slice(0, finUltimoImport + 1) + '
+' + lineaImport + contenidoRoutes.slice(finUltimoImport + 1);
+    } else {
+       contenidoRoutes = lineaImport + '
+' + contenidoRoutes;
+    }
+
+    const cierreArray = contenidoRoutes.lastIndexOf('];');
+    if (cierreArray !== -1) {
+        const nuevaRuta = `  { path: '${nombreRuta}', component: ${nombreClase} },`;
+        const textoAntesDeCierre = contenidoRoutes.slice(0, cierreArray).trimEnd();
+        const necesitaComa = !textoAntesDeCierre.endsWith(',') && !textoAntesDeCierre.endsWith('[');
+        
+        contenidoRoutes = contenidoRoutes.slice(0, cierreArray) + 
+                          (necesitaComa ? ',' : '') + '
+' + 
+                          nuevaRuta + '
+' + 
+                          contenidoRoutes.slice(cierreArray);
+        
+        fs.writeFileSync(rutaRoutes, contenidoRoutes);
+        console.log('Ruta agregada exitosamente.');
+    } else {
+        console.error('No se pudo encontrar el array de rutas en app.routes.ts');
+    }
+  } else {
+      console.error(`No se encontró el archivo de rutas en: ${rutaRoutes}`);
+  }
+
+  // --- Modificar contenedor-principal.component.html ---
+  console.log('Actualizando contenedor-principal.component.html...');
+  const rutaHtml = path.join(process.cwd(), 'src', 'app', 'Paginas', 'contenedor-principal', 'contenedor-principal.component.html');
+  if (fs.existsSync(rutaHtml)) {
+      let contenidoHtml = fs.readFileSync(rutaHtml, 'utf-8');
+      
+      const nuevaTarjeta = `  <app-tarjeta [rutaASeguir]="'${nombreRuta}'" titulo="${titulo}" descripcion="${descripcion}" icono="table_chart"></app-tarjeta>`;
+      
+      const ultimoDiv = contenidoHtml.lastIndexOf('</div>');
+      
+      if (ultimoDiv !== -1) {
+          contenidoHtml = contenidoHtml.slice(0, ultimoDiv) + '
+' + nuevaTarjeta + '
+' + contenidoHtml.slice(ultimoDiv);
+          fs.writeFileSync(rutaHtml, contenidoHtml);
+          console.log('Tarjeta agregada exitosamente.');
+      } else {
+          console.error('No se encontró un </div> de cierre en el HTML del contenedor principal.');
+      }
+  } else {
+      console.error(`No se encontró el archivo HTML en: ${rutaHtml}`);
+  }
+  closeReadLine();
+}
+
+export function showFrontendVersion() {
+  mostrarVersion(path.join(__dirname, '../../package.json'));
+  closeReadLine();
+}

package/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { mostrarVersion, getPackageInfo, closeReadLine } from './utils/index.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { initDb, showDbVersion } from './commands/db.js';
+import { initBackend, updateBackend, addServiceBackend, showBackendVersion } from './commands/backend.js';
+import { initFrontend, updateFrontend, cloneFrontendComponent, commitFrontend, showFrontendVersion } from './commands/frontend.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const program = new Command();
+
+const packageInfo = getPackageInfo(path.join(__dirname, 'package.json'));
+
+if (packageInfo) {
+  program
+    .name('utn')
+    .description('Herramienta CLI unificada para la gestión de plantillas SIGU UTN.')
+    .version(packageInfo.version);
+} else {
+  program
+    .name('utn')
+    .description('Herramienta CLI unificada para la gestión de plantillas SIGU UTN.')
+    .version('0.0.0'); // Fallback version
+}
+
+// Define 'db' command
+program.command('db')
+  .description('Comandos para la gestión de plantillas de base de datos.')
+  .option('--init', 'Inicializa un nuevo proyecto de base de datos.')
+  .option('--version', 'Muestra la versión del módulo de base de datos.')
+  .action(async (options) => {
+    if (options.init) {
+      await initDb();
+    } else if (options.version) {
+      showDbVersion();
+    } else {
+      console.log('Uso: utn db [--init | --version]');
+      closeReadLine();
+    }
+  });
+
+// Define 'backend' command
+program.command('backend')
+  .description('Comandos para la gestión de plantillas de backend (Node.js/Express).')
+  .option('--init', 'Inicializa un nuevo proyecto de backend.')
+  .option('--update', 'Actualiza un proyecto de backend existente.')
+  .option('--add-service', 'Agrega un nuevo servicio al proyecto de backend.')
+  .option('--version', 'Muestra la versión del módulo de backend.')
+  .action(async (options) => {
+    if (options.init) {
+      await initBackend();
+    } else if (options.update) {
+      await updateBackend();
+    } else if (options.addService) {
+      await addServiceBackend();
+    } else if (options.version) {
+      showBackendVersion();
+    } else {
+      console.log('Uso: utn backend [--init | --update | --add-service | --version]');
+      closeReadLine();
+    }
+  });
+
+// Define 'frontend' command
+program.command('frontend')
+  .description('Comandos para la gestión de plantillas de frontend (Angular).')
+  .option('--init', 'Inicializa un nuevo proyecto de frontend.')
+  .option('--update', 'Actualiza un proyecto de frontend existente.')
+  .option('--clone-component', 'Clona un componente existente (e.g., gestion-tabla-XYZ).')
+  .option('--commit', 'Realiza un commit siguiendo el flujo de trabajo predefinido.')
+  .option('--version', 'Muestra la versión del módulo de frontend.')
+  .action(async (options) => {
+    if (options.init) {
+      await initFrontend();
+    } else if (options.update) {
+      await updateFrontend();
+    } else if (options.cloneComponent) {
+      await cloneFrontendComponent();
+    } else if (options.commit) {
+      await commitFrontend();
+    } else if (options.version) {
+      showFrontendVersion();
+    } else {
+      console.log('Uso: utn frontend [--init | --update | --clone-component | --commit | --version]');
+      closeReadLine();
+    }
+  });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+  closeReadLine();
+}