@orxataguy/tyr 1.0.0

package/src/commands/dw.tyr.ts

@@ -0,0 +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': '' 
+//     }
+// }

package/src/commands/install.tyr.ts

@@ -0,0 +1,135 @@
+import { TyrContext } from '../core/Kernel';
+import { homedir, platform } from 'os';
+import { existsSync } from 'fs';
+import path from 'path';
+
+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[]) => {
+        const homeDir = homedir();
+        const isWindows = platform() === 'win32';
+
+        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)) {
+                fail(
+                    `El directorio ${tfgPath} no existe`,
+                    'Asegúrate de que la ruta ~/Projects/TyrFramework existe'
+                );
+            }
+            logger.success(`Directorio TFG encontrado: ${tfgPath}`);
+        });
+
+        await task('Verificando templates', async () => {
+            if (!fs.exists(aliasesTemplatePath)) {
+                fail(
+                    `Template de aliases no encontrado: ${aliasesTemplatePath}`,
+                    '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'
+                );
+            }
+
+            logger.success('Templates encontrados');
+        });
+
+        await task('Creando carpeta local', async () => {
+            await fs.createDir(addonsPath);
+            logger.success(`Carpeta creada: ${addonsPath}`);
+        });
+
+        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')}`);
+        });
+
+        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');
+    };
+};
+
+// export const Test = {
+//     args: []
+// }

package/src/core/Container.ts

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

package/src/core/Kernel.ts

@@ -0,0 +1,165 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { fileURLToPath } from 'url';
+import { Container } from './Container';
+
+import gen from './sys/gen';
+import rem from './sys/rem';
+import doc from './sys/doc';
+import ai from './sys/ai';
+
+import { TyrError } from './TyrError';
+
+interface TyrConfig {
+    commands: Record<string, string>;
+    aliases?: Record<string, string>;
+}
+
+export interface TyrContext {
+    frameworkRoot: string;
+    logger: any;
+    shell: any;
+    fs: any;
+    docker?: any;
+    run: (commandName: string, args?: string[]) => Promise<void>;
+    task: <T>(description: string, action: () => Promise<T> | T, next?: boolean, onFail?: () => void) => Promise<T | undefined>;
+    fail: (msg: string, suggestion?: string) => never;
+    [key: string]: any;
+}
+
+type CommandFunction = (args: string[]) => Promise<void>;
+type CommandFactory = (context: TyrContext) => CommandFunction;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export class Kernel {
+    private container: Container;
+    private config: TyrConfig | null;
+    private frameworkRoot: string;
+
+    constructor() {
+        this.container = new Container();
+        this.config = null;
+        this.frameworkRoot = path.resolve(__dirname, '../../');
+    }
+
+    public async boot(args: string[]): Promise<void> {
+        const isDebug = args.includes('--debug');
+        await this.container.init(isDebug);
+
+        const configPath = path.resolve(this.frameworkRoot, 'config/map.yml');
+
+        try {
+            const fileContents = fs.readFileSync(configPath, 'utf8');
+            this.config = yaml.load(fileContents) as TyrConfig;
+        } catch (error) {
+            console.error(`Critical error: configuration not found at ${configPath}`);
+            process.exit(1);
+        }
+    }
+
+    public async handle(args: string[]): Promise<void> {
+        const commandName = args[0];
+
+        if (!commandName) {
+            console.log("Please provide a command. Example: tyr help");
+            return;
+        }
+
+        const runInternal = async (cmd: string, cmdArgs: string[] = []) => {
+            await this.handle([cmd, ...cmdArgs]);
+        };
+
+        const task = async <T>(description: string, action: () => Promise<T> | T, next: boolean = false, onFail?: () => void): Promise<T | undefined> => {
+            try {
+                return await action();
+            } catch (e) {
+
+                if (onFail) {
+                    onFail();
+                }
+
+                if (!next) {
+                    throw new TyrError(
+                        `Task failed: "${description}"`,
+                        e,
+                        "Check the previous logs or the configuration."
+                    );
+                }
+            }
+        };
+
+        const context: TyrContext = {
+            ...this.container.get(),
+            frameworkRoot: this.frameworkRoot,
+            run: runInternal,
+            task,
+            fail: (msg: string, suggestion?: string) => { throw new TyrError(msg, null, suggestion, commandName); }
+        };
+
+        const systemCommands: Record<string, CommandFactory> = {
+            gen,
+            rem,
+            doc,
+            ai,
+        };
+
+        if (systemCommands[commandName]) {
+            await systemCommands[commandName](context)(args.slice(1));
+            return;
+        }
+
+        if (!this.config) {
+            throw new Error("Kernel has not been initialized (run boot first).");
+        }
+
+        let scriptPath = this.config.commands[commandName];
+
+        if (!scriptPath && this.config.aliases?.[commandName]) {
+            const aliasTarget = this.config.aliases[commandName];
+            scriptPath = this.config.commands[aliasTarget];
+        }
+
+        if (!scriptPath) {
+            context.logger?.error(`Command '${commandName}' not found.`);
+            return;
+        }
+
+        try {
+            const absolutePath = path.resolve(this.frameworkRoot, scriptPath);
+
+            const module = await import(absolutePath);
+
+            if (typeof module.default !== 'function') {
+                throw new Error(`File ${scriptPath} does not export a default function.`);
+            }
+
+            const commandFactory: CommandFactory = module.default;
+            const command = commandFactory(context);
+
+            await command(args.slice(1));
+
+        } catch (error: any) {
+            this.handleError(error, args);
+        }
+    }
+
+    private handleError(error: unknown, args: string[]): void {
+        const isDebug = args.includes('--debug');
+        const logger = this.container.get().logger;
+        const commandName = args[0];
+
+        if (error instanceof TyrError) {
+            const enriched = error.commandName
+                ? error
+                : new TyrError(error.message, error.originalError, error.suggestion, commandName);
+            enriched.handle(isDebug, logger);
+        } else {
+            (new TyrError('Unhandled critical error', error, undefined, commandName)).handle(isDebug, logger);
+        }
+
+        process.exit(1);
+    }
+}

package/src/core/Logger.ts

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+
+export interface Logger {
+    log(msg: any): void;
+    info(msg: any): void;
+    success(msg: any): void;
+    error(msg: any): void;
+    warn(msg: any): void;
+}
+
+export function createLogger(isDebug: boolean): Logger {
+    const logDir = path.join(homedir(), '.tyr', 'logs');
+    const logFile = path.join(logDir, `${new Date().toISOString().slice(0, 10)}.log`);
+
+    fs.mkdirSync(logDir, { recursive: true });
+
+    const writeToFile = (level: string, msg: any) => {
+        const timestamp = new Date().toISOString();
+        const line = `[${timestamp}] [${level}] ${String(msg)}\n`;
+        fs.appendFileSync(logFile, line, 'utf-8');
+    };
+
+    return {
+        log: (msg) => {
+            console.log(msg);
+            writeToFile('LOG', msg);
+        },
+        info: (msg) => {
+            console.log(chalk.blue('ℹ'), msg);
+            writeToFile('INFO', msg);
+        },
+        success: (msg) => {
+            console.log(chalk.green('✔'), msg);
+            writeToFile('SUCCESS', msg);
+        },
+        error: (msg) => {
+            if (isDebug) console.error(chalk.red('✖'), msg);
+            writeToFile('ERROR', msg);
+        },
+        warn: (msg) => {
+            if (isDebug) console.warn(chalk.yellow('⚠'), msg);
+            writeToFile('WARN', msg);
+        },
+    };
+}

package/src/core/TyrError.ts

@@ -0,0 +1,57 @@
+import { Logger, createLogger } from './Logger.js';
+
+export class TyrError extends Error {
+    public readonly originalError: unknown;
+    public readonly isTyrError = true;
+    public readonly suggestion?: string;
+    public readonly commandName?: string;
+
+    constructor(message: string, originalError?: unknown, suggestion?: string, commandName?: string) {
+        super(message);
+        this.originalError = originalError;
+        this.suggestion = suggestion;
+        this.commandName = commandName;
+        Error.captureStackTrace(this, this.constructor);
+    }
+
+    private extractErrorMessage(err: unknown): string {
+        if (err instanceof Error) return err.message;
+        if (typeof err === 'string') return err;
+        try {
+            return JSON.stringify(err);
+        } catch {
+            return 'Unknown error (non-serializable)';
+        }
+    }
+
+    public handle(isDebug: boolean = false, _logger?: Logger): void {
+        const logger = _logger ?? createLogger(isDebug);
+
+        if (this.commandName) {
+            logger.error(`Error in command: ${this.commandName}`);
+        }
+
+        logger.error('Oops! An error occurred.');
+        logger.error(`↳  ${this.message}`);
+
+        if (this.originalError) {
+            logger.error(`      ↳ Caused by: ${this.extractErrorMessage(this.originalError)}`);
+        }
+
+        if (this.suggestion) {
+            logger.warn(`   Suggestion: ${this.suggestion}`);
+        }
+
+        if (isDebug) {
+            if (this.originalError instanceof Error) {
+                logger.log('\n--- Stack Trace ---');
+                logger.log(this.originalError.stack);
+            } else {
+                logger.log('\n--- Stack Trace ---');
+                logger.log(this);
+            }
+        } else {
+            logger.log('\n(Use --debug to see the full stack trace)');
+        }
+    }
+}