@orxataguy/tyr 1.0.0 → 1.3.0

package/bin/tyr.js

@@ -2,24 +2,27 @@
 import { fileURLToPath } from 'url';
 import { dirname, resolve, join } from 'path';
 import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageRoot = resolve(__dirname, '..');
-const isWindows = process.platform === 'win32';
 
-const tsxBin = join(packageRoot, 'node_modules', '.bin', isWindows ? 'tsx.cmd' : 'tsx');
+// Locate tsx's CLI entry directly from its package.json — no shell, no .cmd wrappers
+const tsxPkg = JSON.parse(readFileSync(join(packageRoot, 'node_modules', 'tsx', 'package.json'), 'utf-8'));
+const tsxBinField = tsxPkg.bin;
+const tsxBinRelative = typeof tsxBinField === 'string' ? tsxBinField : (tsxBinField.tsx ?? tsxBinField['tsx']);
+const tsxEntry = join(packageRoot, 'node_modules', 'tsx', tsxBinRelative);
 const entry = join(__dirname, 'tyr.ts');
 
-const child = spawn(tsxBin, [entry, ...process.argv.slice(2)], {
-    stdio: 'inherit',
-    shell: isWindows
+const child = spawn(process.execPath, [tsxEntry, entry, ...process.argv.slice(2)], {
+    stdio: 'inherit'
 });
 
 child.on('exit', (code) => process.exit(code ?? 0));
 child.on('error', (err) => {
     console.error(`Error: Could not start tyr. ${err.message}`);
-    console.error(`tsx not found at: ${tsxBin}`);
-    console.error(`Try reinstalling: npm install -g tyr.framework.cli`);
+    console.error(`tsx not found at: ${tsxEntry}`);
+    console.error('Try reinstalling: npm install -g @orxataguy/tyr');
     process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"
@@ -16,7 +16,7 @@
     "test:watch": "vitest",
     "test:ui": "vitest --ui",
     "test:coverage": "vitest run --coverage",
-    "prepare": "node -e \"const{existsSync}=require('fs');if(!process.env.CI&&existsSync('.git'))require('child_process').execSync('husky',{stdio:'inherit'})\"",
+    "prepare": "node -e \"const{existsSync}=require('fs'),cp=require('child_process'),p=require('path');if(!process.env.CI&&existsSync('.git')){const b=p.join('node_modules','.bin','husky'+(process.platform==='win32'?'.cmd':''));cp.execSync(b,{stdio:'inherit',shell:process.platform==='win32'});}\"",
     "release:patch": "npm version patch && git push --follow-tags",
     "release:minor": "npm version minor && git push --follow-tags",
     "release:major": "npm version major && git push --follow-tags",
@@ -57,4 +57,4 @@
     "vite": "^7.3.1",
     "vitest": "^3.2.4"
   }
-}
+}

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';
-
-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: []
-// }
+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/Kernel.ts

@@ -1,165 +1,206 @@
-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);
-    }
-}
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+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 config from './sys/config';
+
+import { TyrError } from './TyrError';
+
+interface TyrConfig {
+    commands: Record<string, string>;
+    aliases?: Record<string, string>;
+}
+
+export interface TyrContext {
+    frameworkRoot: string;
+    userRoot: 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;
+    private userRoot: string;
+
+    constructor() {
+        this.container = new Container();
+        this.config = null;
+        this.frameworkRoot = path.resolve(__dirname, '../../');
+        this.userRoot = path.join(homedir(), '.tyr');
+    }
+
+    public async boot(args: string[]): Promise<void> {
+        const isDebug = args.includes('--debug');
+        await this.container.init(isDebug);
+
+        // All commands live in ~/.tyr/map.yml — the framework ships no runtime commands
+        this.config = { commands: {}, aliases: {} };
+
+        const userConfigPath = path.join(this.userRoot, 'map.yml');
+        if (fs.existsSync(userConfigPath)) {
+            try {
+                const raw = yaml.load(fs.readFileSync(userConfigPath, 'utf8')) as TyrConfig;
+                for (const [name, cmdPath] of Object.entries(raw.commands ?? {})) {
+                    // Absolute paths used as-is; relative paths resolved from userRoot
+                    this.config.commands[name] = path.isAbsolute(cmdPath)
+                        ? cmdPath
+                        : path.resolve(this.userRoot, cmdPath);
+                }
+                this.config.aliases = raw.aliases ?? {};
+            } catch {
+                console.error(`Warning: could not load user config at ${userConfigPath}`);
+            }
+        }
+    }
+
+    public async handle(args: string[]): Promise<void> {
+        const commandName = args[0];
+
+        if (!commandName) {
+            console.log('Usage: tyr <command> [args...]');
+            console.log('       tyr --config     Configure Tyr for the first time');
+            console.log('       tyr --version    Show version');
+            console.log('       tyr --update     Update Tyr to the latest version');
+            return;
+        }
+
+        // --version / -v
+        if (commandName === '--version' || commandName === '-v') {
+            const pkgPath = path.resolve(this.frameworkRoot, 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            console.log(`tyr v${pkg.version}`);
+            return;
+        }
+
+        // --update
+        if (commandName === '--update') {
+            const pkgPath = path.resolve(this.frameworkRoot, 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const shell = this.container.get().shell;
+            console.log(`Updating ${pkg.name}...`);
+            await shell.exec(`npm update -g ${pkg.name}`);
+            console.log('Update complete. Run tyr --version to confirm.');
+            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,
+            userRoot: this.userRoot,
+            run: runInternal,
+            task,
+            fail: (msg: string, suggestion?: string) => { throw new TyrError(msg, null, suggestion, commandName); }
+        };
+
+        // --config (needs context for fs/logger)
+        if (commandName === '--config') {
+            await config(context)([]);
+            return;
+        }
+
+        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 {
+            // Absolute paths (user commands) are used directly; relative paths resolve from frameworkRoot
+            const absolutePath = path.isAbsolute(scriptPath)
+                ? scriptPath
+                : 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/sys/config.ts

@@ -0,0 +1,161 @@
+import path from 'path';
+import yaml from 'js-yaml';
+import { homedir, platform } from 'os';
+import { existsSync } from 'fs';
+import type { TyrContext } from '../Kernel';
+
+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');
+    }
+
+    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');
+}
+
+const SH_ALIASES_TEMPLATE = `# ~/.tyr/aliases
+# Añade aquí tus aliases personalizados.
+# Este archivo se carga automáticamente por tu shell.
+#
+# Ejemplos:
+#   alias gs='git status'
+#   alias tyr-deploy='tyr deploy'
+`;
+
+const SH_PLUGINS_TEMPLATE = `# ~/.tyr/plugins
+# Añade aquí tus plugins de shell.
+# Compatible con zsh, bash y otros shells POSIX.
+#
+# Ejemplos (zsh):
+#   source /usr/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
+`;
+
+const PS_ALIASES_TEMPLATE = `# ~/.tyr/aliases.ps1
+# Añade aquí tus aliases personalizados para PowerShell.
+#
+# Ejemplos:
+#   Set-Alias gs git-status
+#   function tyr-deploy { tyr deploy @args }
+`;
+
+const PS_PLUGINS_TEMPLATE = `# ~/.tyr/plugins.ps1
+# Añade aquí tus módulos y plugins de PowerShell.
+#
+# Ejemplos:
+#   Import-Module posh-git
+#   Import-Module PSReadLine
+`;
+
+export default function config({ logger, fs: tyrFs, frameworkRoot }: TyrContext) {
+    return async (_args: string[]) => {
+        const homeDir = homedir();
+        const userRoot = path.join(homeDir, '.tyr');
+        const isWindows = platform() === 'win32';
+        const ext = isWindows ? '.ps1' : '';
+
+        logger.info('Iniciando configuración de Tyr...\n');
+
+        // 1. ~/.tyr/commands/
+        await tyrFs.createDir(path.join(userRoot, 'commands'));
+        logger.success(`Directorio creado: ${path.join(userRoot, 'commands')}`);
+
+        // 2. ~/.tyr/aliases(.ps1)
+        const aliasesPath = path.join(userRoot, `aliases${ext}`);
+        if (!tyrFs.exists(aliasesPath)) {
+            await tyrFs.write(aliasesPath, isWindows ? PS_ALIASES_TEMPLATE : SH_ALIASES_TEMPLATE);
+            logger.success(`Archivo creado: ${aliasesPath}`);
+        } else {
+            logger.info(`Ya existe: ${aliasesPath}`);
+        }
+
+        // 3. ~/.tyr/plugins(.ps1)
+        const pluginsPath = path.join(userRoot, `plugins${ext}`);
+        if (!tyrFs.exists(pluginsPath)) {
+            await tyrFs.write(pluginsPath, isWindows ? PS_PLUGINS_TEMPLATE : SH_PLUGINS_TEMPLATE);
+            logger.success(`Archivo creado: ${pluginsPath}`);
+        } else {
+            logger.info(`Ya existe: ${pluginsPath}`);
+        }
+
+        // 4. ~/.tyr/map.yml — create or update, registering framework commands with absolute paths
+        const mapPath = path.join(userRoot, 'map.yml');
+        const currentRaw = await tyrFs.read(mapPath);
+        const userConfig: { commands: Record<string, string> } =
+            (yaml.load(currentRaw ?? '') as any) ?? { commands: {} };
+        if (!userConfig.commands) userConfig.commands = {};
+
+        const frameworkMapPath = path.join(frameworkRoot, 'config', 'map.yml');
+        if (existsSync(frameworkMapPath)) {
+            const frameworkRaw = await tyrFs.read(frameworkMapPath);
+            const frameworkConfig = (yaml.load(frameworkRaw ?? '') as any) ?? {};
+            for (const [name, relPath] of Object.entries(frameworkConfig.commands ?? {})) {
+                const absPath = path.resolve(frameworkRoot, relPath as string);
+                if (existsSync(absPath) && !userConfig.commands[name]) {
+                    userConfig.commands[name] = absPath;
+                    logger.info(`  Comando registrado: ${name}`);
+                }
+            }
+        }
+
+        await tyrFs.write(mapPath, yaml.dump(userConfig, { indent: 2, lineWidth: -1 }));
+        logger.success(`Configuración guardada: ${mapPath}`);
+
+        // 5. Configure shell to source aliases and plugins
+        logger.info('\nConfigurando shell...');
+        if (isWindows) {
+            await configureWindowsShell(tyrFs, logger, aliasesPath, pluginsPath);
+        } else {
+            await configureUnixShell(tyrFs, logger, homeDir, aliasesPath, pluginsPath);
+        }
+
+        logger.success('\nTyr configurado correctamente.');
+        logger.info(`\nDirectorio de configuración: ${userRoot}`);
+        logger.info('\nPróximos pasos:');
+        logger.info('  tyr gen <nombre> <archivo>   Crear un nuevo comando');
+        logger.info('  tyr doc                      Ver documentación de la API');
+    };
+}
+
+async function configureUnixShell(
+    tyrFs: any, logger: any,
+    homeDir: string, aliasesPath: string, pluginsPath: string
+): Promise<void> {
+    const rcFile = detectShellRcFile(homeDir);
+    if (!rcFile) {
+        logger.warn('No se pudo detectar el archivo de configuración del shell.');
+        logger.info(`Añade manualmente:\n  source "${aliasesPath}"\n  source "${pluginsPath}"`);
+        return;
+    }
+    await tyrFs.ensureLine(rcFile, `source "${aliasesPath}"`);
+    await tyrFs.ensureLine(rcFile, `source "${pluginsPath}"`);
+    logger.success(`Shell configurado: ${rcFile}`);
+    logger.info(`Ejecuta: source ${rcFile}  (o abre una nueva terminal)`);
+}
+
+async function configureWindowsShell(
+    tyrFs: any, logger: any,
+    aliasesPath: string, pluginsPath: string
+): Promise<void> {
+    const psProfile = process.env.USERPROFILE
+        ? path.join(process.env.USERPROFILE, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1')
+        : null;
+
+    if (!psProfile) {
+        logger.warn('No se pudo detectar el perfil de PowerShell.');
+        logger.info(`Añade manualmente:\n  . "${aliasesPath}"\n  . "${pluginsPath}"`);
+        return;
+    }
+    await tyrFs.ensureLine(psProfile, `. "${aliasesPath}"`);
+    await tyrFs.ensureLine(psProfile, `. "${pluginsPath}"`);
+    logger.success(`Perfil de PowerShell configurado: ${psProfile}`);
+    logger.info('Reinicia PowerShell para aplicar los cambios.');
+}

package/src/core/sys/gen.ts

@@ -1,72 +1,73 @@
-import path from 'path';
-import yaml from 'js-yaml';
-import type { TyrContext } from '../Kernel';
-
-interface TyrConfig {
-    commands: Record<string, string>;
-    aliases?: Record<string, string>;
-}
-
-const template = `
-import { TyrContext } from '../core/Kernel';
-
-export default ({ run, task, fail, logger }: TyrContext) => {
-    return async (args: string[]) => {
-        logger.info("Ejecutando comando: %s");
-        
-        // Tu lógica aquí...
-        // Ejecuta "tyr doc" para ver la documentación
-        
-        logger.success("¡Comando %s finalizado!");
-    };
-};
-
-export const Test = { args: [ ] };
-`;
-
-export default function gen({ logger, fs, frameworkRoot }: TyrContext) {
-    return async (args: string[]) => {
-        const commandName = args[0];
-        const fileName = args[1];
-
-        if (!commandName || !fileName) {
-            logger.error("Uso incorrecto.");
-            logger.info("Sintaxis: tyr gen [nombre-comando] [nombre-archivo]");
-            return;
-        }
-
-        logger.info(`🔨 Creando nuevo comando: '${commandName}' -> '${fileName}.tyr.ts'`);
-
-        const filePath = path.resolve(frameworkRoot, 'src/commands', `${fileName}.tyr.ts`);
-
-        const templateFilled = template.replaceAll('%s', commandName);
-
-        if (await fs.exists(filePath)) {
-            logger.error(`El archivo ${fileName}.tyr.ts ya existe. Abortando.`);
-            return;
-        }
-
-        await fs.write(filePath, templateFilled.trim());
-
-        const configPath = path.resolve(frameworkRoot, 'config/map.yml');
-
-        try {
-            const currentConfigRaw = await fs.read(configPath);
-            const config = yaml.load(currentConfigRaw) as unknown as TyrConfig;
-
-            if (config.commands[commandName]) {
-                logger.warn(`El comando '${commandName}' ya existía. Actualizando ruta...`);
-            }
-
-            config.commands[commandName] = `./src/commands/${fileName}.tyr.ts`;
-
-            const newYaml = yaml.dump(config, { indent: 2, lineWidth: -1 });
-            await fs.write(configPath, newYaml);
-
-            logger.success(`✅ Comando '${commandName}' registrado en el núcleo (.tyr.ts).`);
-        } catch (e) {
-            logger.error("Error al actualizar la configuración.");
-            console.error(e);
-        }
-    };
-};
+import path from 'path';
+import yaml from 'js-yaml';
+import type { TyrContext } from '../Kernel';
+
+interface TyrConfig {
+    commands: Record<string, string>;
+    aliases?: Record<string, string>;
+}
+
+const template = `export default ({ run, task, fail, logger, shell, fs }: any) => {
+    return async (args: string[]) => {
+        logger.info("Ejecutando comando: %s");
+
+        // Tu lógica aquí...
+        // Ejecuta "tyr doc" para ver la documentación de managers disponibles
+
+        logger.success("¡Comando %s finalizado!");
+    };
+};
+
+export const Test = { args: [] };
+`;
+
+export default function gen({ logger, fs, userRoot }: TyrContext) {
+    return async (args: string[]) => {
+        const commandName = args[0];
+        const fileName = args[1];
+
+        if (!commandName || !fileName) {
+            logger.error('Uso incorrecto.');
+            logger.info('Sintaxis: tyr gen [nombre-comando] [nombre-archivo]');
+            return;
+        }
+
+        logger.info(`Creando nuevo comando: '${commandName}' -> '${fileName}.tyr.ts'`);
+
+        const commandsDir = path.join(userRoot, 'commands');
+        const filePath = path.join(commandsDir, `${fileName}.tyr.ts`);
+
+        if (fs.exists(filePath)) {
+            logger.error(`El archivo ${fileName}.tyr.ts ya existe. Abortando.`);
+            return;
+        }
+
+        const templateFilled = template.replaceAll('%s', commandName);
+        await fs.write(filePath, templateFilled.trim());
+
+        // Register in ~/.tyr/map.yml
+        const mapPath = path.join(userRoot, 'map.yml');
+        try {
+            const currentConfigRaw = await fs.read(mapPath);
+            const config = (yaml.load(currentConfigRaw ?? 'commands: {}') ?? { commands: {} }) as TyrConfig;
+
+            if (!config.commands) config.commands = {};
+
+            if (config.commands[commandName]) {
+                logger.warn(`El comando '${commandName}' ya existía. Actualizando ruta...`);
+            }
+
+            // Store path relative to userRoot so it remains portable
+            config.commands[commandName] = `./commands/${fileName}.tyr.ts`;
+
+            const newYaml = yaml.dump(config, { indent: 2, lineWidth: -1 });
+            await fs.write(mapPath, newYaml);
+
+            logger.success(`Comando '${commandName}' creado en ${filePath}`);
+            logger.success(`Registrado en ${mapPath}`);
+        } catch (e) {
+            logger.error('Error al actualizar la configuración.');
+            console.error(e);
+        }
+    };
+}

package/src/core/sys/rem.ts

@@ -1,57 +1,61 @@
-import path from 'path';
-import yaml from 'js-yaml';
-import type { TyrContext } from '../Kernel';
-
-interface TyrConfig {
-    commands: Record<string, string>;
-    aliases?: Record<string, string>;
-}
-
-export default function rem({ logger, fs, frameworkRoot }: TyrContext) {
-    return async (args: string[]) => {
-        const commandName = args[0];
-
-        if (!commandName) {
-            logger.error("Falta el nombre del comando a eliminar.");
-            return;
-        }
-
-        logger.info(`Iniciando eliminación del comando: '${commandName}'`);
-        const configPath = path.resolve(frameworkRoot, 'config/map.yml');
-
-        try {
-            const currentConfigRaw = await fs.read(configPath);
-            const config = yaml.load(currentConfigRaw) as unknown as TyrConfig;
-
-            if (!config.commands[commandName]) {
-                logger.error(`El comando '${commandName}' no existe.`);
-                return;
-            }
-
-            const relativeScriptPath = config.commands[commandName];
-            const absoluteScriptPath = path.resolve(frameworkRoot, relativeScriptPath);
-
-            await fs.delete(absoluteScriptPath);
-
-            delete config.commands[commandName];
-
-            if (config.aliases) {
-                for (const [alias, target] of Object.entries(config.aliases)) {
-                    if (target === commandName) {
-                        delete config.aliases[alias];
-                        logger.info(`Alias '${alias}' eliminado.`);
-                    }
-                }
-            }
-
-            const newYaml = yaml.dump(config, { indent: 2, lineWidth: -1 });
-            await fs.write(configPath, newYaml);
-
-            logger.success(`Comando '${commandName}' eliminado.`);
-
-        } catch (e) {
-            logger.error("Error crítico durante la eliminación.");
-            console.error(e);
-        }
-    };
-};
+import path from 'path';
+import yaml from 'js-yaml';
+import type { TyrContext } from '../Kernel';
+
+interface TyrConfig {
+    commands: Record<string, string>;
+    aliases?: Record<string, string>;
+}
+
+export default function rem({ logger, fs, userRoot }: TyrContext) {
+    return async (args: string[]) => {
+        const commandName = args[0];
+
+        if (!commandName) {
+            logger.error('Falta el nombre del comando a eliminar.');
+            return;
+        }
+
+        logger.info(`Iniciando eliminación del comando: '${commandName}'`);
+
+        const mapPath = path.join(userRoot, 'map.yml');
+
+        try {
+            const currentConfigRaw = await fs.read(mapPath);
+            if (!currentConfigRaw) {
+                logger.error(`No se encontró ${mapPath}. Ejecuta 'tyr --config' primero.`);
+                return;
+            }
+
+            const config = yaml.load(currentConfigRaw) as TyrConfig;
+
+            if (!config.commands?.[commandName]) {
+                logger.error(`El comando '${commandName}' no existe en ~/.tyr/map.yml.`);
+                return;
+            }
+
+            const relativeScriptPath = config.commands[commandName];
+            const absoluteScriptPath = path.resolve(userRoot, relativeScriptPath);
+
+            await fs.delete(absoluteScriptPath);
+            delete config.commands[commandName];
+
+            if (config.aliases) {
+                for (const [alias, target] of Object.entries(config.aliases)) {
+                    if (target === commandName) {
+                        delete config.aliases[alias];
+                        logger.info(`Alias '${alias}' eliminado.`);
+                    }
+                }
+            }
+
+            const newYaml = yaml.dump(config, { indent: 2, lineWidth: -1 });
+            await fs.write(mapPath, newYaml);
+
+            logger.success(`Comando '${commandName}' eliminado.`);
+        } catch (e) {
+            logger.error('Error crítico durante la eliminación.');
+            console.error(e);
+        }
+    };
+}

package/src/lib/SQLManager.ts

@@ -1,13 +1,10 @@
-import 'dotenv/config';
 import dotenv from 'dotenv';
 import path from 'path';
-import { fileURLToPath } from 'url';
+import { homedir } from 'os';
 import sql, { config as SQLConfig } from 'mssql';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-dotenv.config({ path: path.resolve(__dirname, '../../.env') });
+// Load credentials from ~/.tyr/.env — silently, optional
+(dotenv as any).config({ path: path.join(homedir(), '.tyr', '.env'), quiet: true });
 
 /**
  * @class SQLManager