@orxataguy/tyr 1.0.0 → 1.0.2

package/src/commands/dw.tyr.ts

@@ -1,116 +1,116 @@
-import { TyrContext } from '../core/Kernel';
-
-export default ({ task, fail, logger, shell, db, git, fs }: TyrContext) => {
-    /**
-     * @method extractBranchName
-     * @description Extrae el nombre de rama de una URL o devuelve el nombre tal cual
-     */
-    const extractBranchName = (input: string): string => {
-        if (input.includes('/')) {
-            const parts = input.split('/');
-            return parts[parts.length - 1];
-        }
-        return input;
-    };
-
-    return async (args: string[]) => {
-
-        // Validación de argumentos
-        if (args.length === 0) {
-            fail(
-                'No se especificó la URL del cliente',
-                'Uso: clone-client <url-cliente> [url-rama-opcional]'
-            );
-        }
-
-        const clientUrl = args[0];
-        const branchUrlOrName = args[1] || null;
-
-        logger.info('Navegando al directorio de clientes...');
-        shell.cd('~/dev/wolbenvironment/dev/websITS/clients');
-        console.log("Lanzo con url:", clientUrl)
-        const broker = await task('Buscando broker en la base de datos', async () => {
-            const result = await db.searchBrokerOnDB(clientUrl);
-
-            if (!result) {
-                fail(
-                    `No se encontró broker para la URL: ${clientUrl}`,
-                    'Verifica que la URL sea correcta y esté registrada en la BD'
-                );
-            }
-
-            logger.success(`Broker encontrado: ${result}`);
-            return result;
-        });
-
-        const brokerPath = `~/dev/wolbenvironment/dev/websITS/clients/${broker}`;
-        const dirExists = fs.exists(brokerPath);
-
-        if (dirExists) {
-            logger.warn(`El directorio '${broker}' ya existe`);
-
-            const choice = await shell.input(
-                '¿Qué deseas hacer? (s)obrescribir / (m)antener / (r)enombrar: '
-            );
-
-            if (choice.toLowerCase() === 'm' || choice.toLowerCase() === 'mantener') {
-                logger.info('Manteniendo directorio existente. Finalizando...');
-                return;
-            } else if (choice.toLowerCase() === 'r' || choice.toLowerCase() === 'renombrar') {
-                await task('Renombrando directorio existente', async () => {
-                    await shell.exec(`mv ${broker} ${broker}.bak`);
-                    logger.success(`Directorio renombrado a: ${broker}.bak`);
-                });
-            } else if (choice.toLowerCase() === 's' || choice.toLowerCase() === 'sobrescribir') {
-                await task('Eliminando directorio existente', async () => {
-                    await shell.exec(`rm -rf ${broker}`);
-                    logger.success('Directorio eliminado');
-                });
-            } else {
-                fail('Opción no válida', 'Usa: s (sobrescribir), m (mantener) o r (renombrar)');
-            }
-        }
-
-        const repoUrl = `git@github.com:Avantio/${broker}`;
-        logger.info(`Repositorio: ${repoUrl}`);
-
-        const loader = shell.showLoader('Clonando repositorio desde GitHub...');
-
-        await task('Clonando repositorio', async () => {
-            await git.clone(repoUrl);
-            loader.stop();
-            logger.success('Repositorio clonado exitosamente');
-        }, false, () => loader.stop());
-
-        shell.cd(broker);
-
-        let branchName: string;
-
-        if (branchUrlOrName) {
-            branchName = extractBranchName(branchUrlOrName);
-            logger.info(`Rama extraída: ${branchName}`);
-        } else {
-            const answer = await shell.input('🌿 ¿Qué rama quieres usar? (nombre o URL): ');
-            branchName = extractBranchName(answer);
-        }
-
-        await task(`Cambiando a la rama: ${branchName}`, async () => {
-            if (branchName.length > 0) {
-                await shell.exec(`git checkout -b ${branchName}`);
-                logger.success(`Ahora estás en la rama: ${branchName}`);
-            } else {
-                logger.info('No se va a generar ninguna rama nueva')
-            }
-        });
-        logger.success(`Repositorio ${broker} clonado y configurado exitosamente`);
-
-    };
-};
-
-// export const Test = {
-//     args: ['https://www.feelporto.com/'],
-//     mockInputs: {
-//         'sobrescribir': 'm',  
-//         'rama': '' 
-//     }
+import { TyrContext } from '../core/Kernel';
+
+export default ({ task, fail, logger, shell, db, git, fs }: TyrContext) => {
+    /**
+     * @method extractBranchName
+     * @description Extrae el nombre de rama de una URL o devuelve el nombre tal cual
+     */
+    const extractBranchName = (input: string): string => {
+        if (input.includes('/')) {
+            const parts = input.split('/');
+            return parts[parts.length - 1];
+        }
+        return input;
+    };
+
+    return async (args: string[]) => {
+
+        // Validación de argumentos
+        if (args.length === 0) {
+            fail(
+                'No se especificó la URL del cliente',
+                'Uso: clone-client <url-cliente> [url-rama-opcional]'
+            );
+        }
+
+        const clientUrl = args[0];
+        const branchUrlOrName = args[1] || null;
+
+        logger.info('Navegando al directorio de clientes...');
+        shell.cd('~/dev/wolbenvironment/dev/websITS/clients');
+        console.log("Lanzo con url:", clientUrl)
+        const broker = await task('Buscando broker en la base de datos', async () => {
+            const result = await db.searchBrokerOnDB(clientUrl);
+
+            if (!result) {
+                fail(
+                    `No se encontró broker para la URL: ${clientUrl}`,
+                    'Verifica que la URL sea correcta y esté registrada en la BD'
+                );
+            }
+
+            logger.success(`Broker encontrado: ${result}`);
+            return result;
+        });
+
+        const brokerPath = `~/dev/wolbenvironment/dev/websITS/clients/${broker}`;
+        const dirExists = fs.exists(brokerPath);
+
+        if (dirExists) {
+            logger.warn(`El directorio '${broker}' ya existe`);
+
+            const choice = await shell.input(
+                '¿Qué deseas hacer? (s)obrescribir / (m)antener / (r)enombrar: '
+            );
+
+            if (choice.toLowerCase() === 'm' || choice.toLowerCase() === 'mantener') {
+                logger.info('Manteniendo directorio existente. Finalizando...');
+                return;
+            } else if (choice.toLowerCase() === 'r' || choice.toLowerCase() === 'renombrar') {
+                await task('Renombrando directorio existente', async () => {
+                    await shell.exec(`mv ${broker} ${broker}.bak`);
+                    logger.success(`Directorio renombrado a: ${broker}.bak`);
+                });
+            } else if (choice.toLowerCase() === 's' || choice.toLowerCase() === 'sobrescribir') {
+                await task('Eliminando directorio existente', async () => {
+                    await shell.exec(`rm -rf ${broker}`);
+                    logger.success('Directorio eliminado');
+                });
+            } else {
+                fail('Opción no válida', 'Usa: s (sobrescribir), m (mantener) o r (renombrar)');
+            }
+        }
+
+        const repoUrl = `git@github.com:Avantio/${broker}`;
+        logger.info(`Repositorio: ${repoUrl}`);
+
+        const loader = shell.showLoader('Clonando repositorio desde GitHub...');
+
+        await task('Clonando repositorio', async () => {
+            await git.clone(repoUrl);
+            loader.stop();
+            logger.success('Repositorio clonado exitosamente');
+        }, false, () => loader.stop());
+
+        shell.cd(broker);
+
+        let branchName: string;
+
+        if (branchUrlOrName) {
+            branchName = extractBranchName(branchUrlOrName);
+            logger.info(`Rama extraída: ${branchName}`);
+        } else {
+            const answer = await shell.input('🌿 ¿Qué rama quieres usar? (nombre o URL): ');
+            branchName = extractBranchName(answer);
+        }
+
+        await task(`Cambiando a la rama: ${branchName}`, async () => {
+            if (branchName.length > 0) {
+                await shell.exec(`git checkout -b ${branchName}`);
+                logger.success(`Ahora estás en la rama: ${branchName}`);
+            } else {
+                logger.info('No se va a generar ninguna rama nueva')
+            }
+        });
+        logger.success(`Repositorio ${broker} clonado y configurado exitosamente`);
+
+    };
+};
+
+// export const Test = {
+//     args: ['https://www.feelporto.com/'],
+//     mockInputs: {
+//         'sobrescribir': 'm',  
+//         'rama': '' 
+//     }
 // }

package/src/commands/install.tyr.ts

@@ -1,135 +1,61 @@
 import { TyrContext } from '../core/Kernel';
-import { homedir, platform } from 'os';
-import { existsSync } from 'fs';
 import path from 'path';
+import { homedir } from 'os';
 
-function detectShellRcFile(homeDir: string): string | null {
-    const shell = process.env.SHELL || '';
-
-    if (shell.includes('zsh')) return path.join(homeDir, '.zshrc');
-    if (shell.includes('fish')) return path.join(homeDir, '.config', 'fish', 'config.fish');
-    if (shell.includes('bash')) {
-        const candidates = [
-            path.join(homeDir, '.bash_profile'),
-            path.join(homeDir, '.bashrc'),
-        ];
-        return candidates.find(p => existsSync(p)) ?? path.join(homeDir, '.bashrc');
-    }
-
-    // Fallback: try common files in order
-    const fallbacks = [
-        path.join(homeDir, '.zshrc'),
-        path.join(homeDir, '.bashrc'),
-        path.join(homeDir, '.bash_profile'),
-    ];
-    return fallbacks.find(p => existsSync(p)) ?? path.join(homeDir, '.bashrc');
-}
-
-async function getPowerShellProfile(shell: any): Promise<string | null> {
-    try {
-        const profile = await shell.exec('powershell -NoProfile -Command "$PROFILE"').catch(() => null);
-        return profile?.trim() || null;
-    } catch {
-        return null;
-    }
-}
-
-export default ({ task, fail, logger, fs, shell }: TyrContext) => {
-    return async (args: string[]) => {
+export default ({ task, fail, logger, fs }: TyrContext) => {
+    return async (_args: string[]) => {
         const homeDir = homedir();
-        const isWindows = platform() === 'win32';
+        const userRoot = path.join(homeDir, '.tyr');
 
-        const tfgPath = path.join(homeDir, 'Projects', 'TyrFramework');
-        const addonsPath = path.join(tfgPath, 'local');
         const aliasesTemplatePath = path.join(homeDir, 'avantio', 'framework', 'core', 'include', 'bin', 'aliases.template.sh');
         const pluginsTemplatePath = path.join(homeDir, 'avantio', 'framework', 'core', 'include', 'bin', 'plugins.template.sh');
 
-        await task('Verificando directorio TFG', async () => {
-            if (!fs.exists(tfgPath)) {
+        const aliasesTarget = path.join(userRoot, 'aliases');
+        const pluginsTarget = path.join(userRoot, 'plugins');
+
+        await task('Verificando configuración de Tyr', async () => {
+            if (!fs.exists(userRoot)) {
                 fail(
-                    `El directorio ${tfgPath} no existe`,
-                    'Asegúrate de que la ruta ~/Projects/TyrFramework existe'
+                    'El directorio ~/.tyr no existe.',
+                    "Ejecuta 'tyr --config' antes de continuar."
                 );
             }
-            logger.success(`Directorio TFG encontrado: ${tfgPath}`);
+            logger.success(`Directorio ~/.tyr encontrado: ${userRoot}`);
         });
 
-        await task('Verificando templates', async () => {
+        await task('Verificando templates de Avantio', async () => {
             if (!fs.exists(aliasesTemplatePath)) {
                 fail(
                     `Template de aliases no encontrado: ${aliasesTemplatePath}`,
-                    'Verifica que el framework de Avantio esté correctamente instalado'
+                    'Verifica que el framework de Avantio esté correctamente instalado.'
                 );
             }
-
             if (!fs.exists(pluginsTemplatePath)) {
                 fail(
                     `Template de plugins no encontrado: ${pluginsTemplatePath}`,
-                    'Verifica que el framework de Avantio esté correctamente instalado'
+                    'Verifica que el framework de Avantio esté correctamente instalado.'
                 );
             }
-
-            logger.success('Templates encontrados');
+            logger.success('Templates de Avantio encontrados.');
         });
 
-        await task('Creando carpeta local', async () => {
-            await fs.createDir(addonsPath);
-            logger.success(`Carpeta creada: ${addonsPath}`);
+        await task('Copiando aliases de Avantio', async () => {
+            const content = await fs.read(aliasesTemplatePath);
+            if (!content) fail('No se pudo leer aliases.template.sh');
+            await fs.write(aliasesTarget, content!);
+            logger.success(`Aliases copiados a: ${aliasesTarget}`);
         });
 
-        await task('Copiando aliases.template.sh', async () => {
-            const aliasesContent = await fs.read(aliasesTemplatePath);
-            if (!aliasesContent) {
-                fail('No se pudo leer el contenido de aliases.template.sh');
-            }
-            await fs.write(path.join(addonsPath, 'aliases.sh'), aliasesContent!);
-            logger.success(`Archivo creado: ${path.join(addonsPath, 'aliases.sh')}`);
-        });
-
-        await task('Copiando plugins.template.sh', async () => {
-            const pluginsContent = await fs.read(pluginsTemplatePath);
-            if (!pluginsContent) {
-                fail('No se pudo leer el contenido de plugins.template.sh');
-            }
-            await fs.write(path.join(addonsPath, 'plugins.sh'), pluginsContent!);
-            logger.success(`Archivo creado: ${path.join(addonsPath, 'plugins.sh')}`);
+        await task('Copiando plugins de Avantio', async () => {
+            const content = await fs.read(pluginsTemplatePath);
+            if (!content) fail('No se pudo leer plugins.template.sh');
+            await fs.write(pluginsTarget, content!);
+            logger.success(`Plugins copiados a: ${pluginsTarget}`);
         });
 
-        if (isWindows) {
-            await task('Configurando perfil de PowerShell', async () => {
-                const psProfile = await getPowerShellProfile(shell);
-                if (psProfile) {
-                    const sourceLine = `. "${path.join(addonsPath, 'aliases.sh')}"`;
-                    await fs.ensureLine(psProfile, sourceLine);
-                    logger.success(`Aliases añadidos al perfil de PowerShell: ${psProfile}`);
-                    logger.info('Reinicia PowerShell para aplicar los cambios');
-                } else {
-                    logger.warn('No se pudo detectar el perfil de PowerShell.');
-                    logger.info(`Añade manualmente a tu perfil: . "${path.join(addonsPath, 'aliases.sh')}"`);
-                }
-            });
-        } else {
-            await task('Configurando shell', async () => {
-                const rcFile = detectShellRcFile(homeDir);
-                if (!rcFile) {
-                    logger.warn('No se pudo detectar el archivo de configuración de shell. Configura manualmente.');
-                    return;
-                }
-
-                const sourceLine = `source "${path.join(addonsPath, 'aliases.sh')}"`;
-                await fs.ensureLine(rcFile, sourceLine);
-                logger.success(`Aliases añadidos a: ${rcFile}`);
-                logger.info(`Ejecuta: source ${rcFile}  (o abre una nueva terminal)`);
-            });
-        }
-
-        logger.success('\nEstructura de addons configurada exitosamente');
-        logger.info(`\nArchivos creados en: ${addonsPath}`);
-        logger.info('  - aliases.sh');
-        logger.info('  - plugins.sh');
+        logger.success('\nInstalación de Avantio completada.');
+        logger.info(`  aliases → ${aliasesTarget}`);
+        logger.info(`  plugins → ${pluginsTarget}`);
+        logger.warn('\nRecuerda recargar tu shell para aplicar los cambios.');
     };
 };
-
-// export const Test = {
-//     args: []
-// }

package/src/core/Container.ts

@@ -1,56 +1,56 @@
-import { ShellManager } from '../lib/ShellManager.js';
-import { FileSystemManager } from '../lib/FileSystemManager.js';
-import { PackageManager } from '../lib/PackageManager.js';
-import { DockerManager } from '../lib/DockerManager.js';
-import { GitManager } from '../lib/GitManager.js';
-import { SystemManager } from '../lib/SystemManager.js';
-import { SQLManager } from '../lib/SQLManager.js';
-import { WebManager } from '../lib/WebManager.js';
-import { Logger, createLogger } from './Logger.js';
-
-export type { Logger };
-
-export interface ServiceContainer {
-    logger: Logger;
-    shell: ShellManager;
-    fs: FileSystemManager;
-    pkg: PackageManager;
-    docker: DockerManager;
-    git: GitManager;
-    sys: SystemManager;
-    db: SQLManager;
-    web: WebManager;
-}
-
-export class Container {
-    private services: Partial<ServiceContainer>;
-
-    constructor() {
-        this.services = {};
-    }
-
-    public init(isDebug: boolean): void {
-        const logger = createLogger(isDebug);
-        const shell = new ShellManager();
-        const db = new SQLManager();
-
-        this.services = {
-            logger,
-            shell,
-            db,
-            web: new WebManager(logger),
-            fs: new FileSystemManager(logger),
-            pkg: new PackageManager(shell, logger),
-            docker: new DockerManager(shell, logger),
-            git: new GitManager(shell, logger),
-            sys: new SystemManager(shell, logger),
-        };
-    }
-
-    public get(): ServiceContainer {
-        if (!this.services.logger) {
-            throw new Error('Container not initialised. Call .init() first.');
-        }
-        return this.services as ServiceContainer;
-    }
-}
+import { ShellManager } from '../lib/ShellManager.js';
+import { FileSystemManager } from '../lib/FileSystemManager.js';
+import { PackageManager } from '../lib/PackageManager.js';
+import { DockerManager } from '../lib/DockerManager.js';
+import { GitManager } from '../lib/GitManager.js';
+import { SystemManager } from '../lib/SystemManager.js';
+import { SQLManager } from '../lib/SQLManager.js';
+import { WebManager } from '../lib/WebManager.js';
+import { Logger, createLogger } from './Logger.js';
+
+export type { Logger };
+
+export interface ServiceContainer {
+    logger: Logger;
+    shell: ShellManager;
+    fs: FileSystemManager;
+    pkg: PackageManager;
+    docker: DockerManager;
+    git: GitManager;
+    sys: SystemManager;
+    db: SQLManager;
+    web: WebManager;
+}
+
+export class Container {
+    private services: Partial<ServiceContainer>;
+
+    constructor() {
+        this.services = {};
+    }
+
+    public init(isDebug: boolean): void {
+        const logger = createLogger(isDebug);
+        const shell = new ShellManager();
+        const db = new SQLManager();
+
+        this.services = {
+            logger,
+            shell,
+            db,
+            web: new WebManager(logger),
+            fs: new FileSystemManager(logger),
+            pkg: new PackageManager(shell, logger),
+            docker: new DockerManager(shell, logger),
+            git: new GitManager(shell, logger),
+            sys: new SystemManager(shell, logger),
+        };
+    }
+
+    public get(): ServiceContainer {
+        if (!this.services.logger) {
+            throw new Error('Container not initialised. Call .init() first.');
+        }
+        return this.services as ServiceContainer;
+    }
+}