@orxataguy/tyr 1.5.0 → 1.6.2

package/src/commands/install.tyr.ts

@@ -1,61 +1,61 @@
-import { TyrContext } from '../core/Kernel';
-import path from 'path';
-import { homedir } from 'os';
-
-export default ({ task, fail, logger, fs }: TyrContext) => {
-    return async (_args: string[]) => {
-        const homeDir = homedir();
-        const userRoot = path.join(homeDir, '.tyr');
-
-        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');
-
-        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 ~/.tyr no existe.',
-                    "Ejecuta 'tyr --config' antes de continuar."
-                );
-            }
-            logger.success(`Directorio ~/.tyr encontrado: ${userRoot}`);
-        });
-
-        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.'
-                );
-            }
-            if (!fs.exists(pluginsTemplatePath)) {
-                fail(
-                    `Template de plugins no encontrado: ${pluginsTemplatePath}`,
-                    'Verifica que el framework de Avantio esté correctamente instalado.'
-                );
-            }
-            logger.success('Templates de Avantio encontrados.');
-        });
-
-        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 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}`);
-        });
-
-        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.');
-    };
-};
+import { TyrContext } from '../core/Kernel';
+import path from 'path';
+import { homedir } from 'os';
+
+export default ({ task, fail, logger, fs }: TyrContext) => {
+    return async (_args: string[]) => {
+        const homeDir = homedir();
+        const userRoot = path.join(homeDir, '.tyr');
+
+        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');
+
+        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 ~/.tyr no existe.',
+                    "Ejecuta 'tyr --config' antes de continuar."
+                );
+            }
+            logger.success(`Directorio ~/.tyr encontrado: ${userRoot}`);
+        });
+
+        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.'
+                );
+            }
+            if (!fs.exists(pluginsTemplatePath)) {
+                fail(
+                    `Template de plugins no encontrado: ${pluginsTemplatePath}`,
+                    'Verifica que el framework de Avantio esté correctamente instalado.'
+                );
+            }
+            logger.success('Templates de Avantio encontrados.');
+        });
+
+        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 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}`);
+        });
+
+        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.');
+    };
+};

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;
+    }
+}

package/src/core/Kernel.ts

@@ -134,7 +134,7 @@ export class Kernel {
 
         // --config (needs context for fs/logger)
         if (commandName === '--config') {
-            await config(context)([]);
+            await config(context)(args.slice(1));
             return;
         }
 

package/src/core/Logger.ts

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

@@ -1,57 +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)');
-        }
-    }
-}
+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)');
+        }
+    }
+}