@orxataguy/tyr 1.0.0 → 1.0.2

package/src/core/sys/gen.ts

@@ -1,72 +1,75 @@
-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 = `import type { TyrContext } from '@orxataguy/tyr';
+
+export default ({ run, task, fail, logger, shell, fs }: TyrContext) => {
+    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/index.ts

@@ -0,0 +1,5 @@
+// Public API of @orxataguy/tyr
+// Import types from here in your ~/.tyr/commands/ files:
+//   import type { TyrContext } from '@orxataguy/tyr';
+
+export type { TyrContext } from './core/Kernel.js';

package/src/lib/DockerManager.ts

@@ -1,108 +1,108 @@
-import { ShellManager } from './ShellManager.js';
-import { Logger } from '../core/Logger.js';
-import { TyrError } from '../core/TyrError.js';
-
-export interface DockerRunOptions {
-    image: string;
-    name: string;
-    port?: string;
-    env?: string[];
-}
-
-/**
- * @class DockerManager
- * @description Low-level manager for interacting with the Docker Daemon.
- * Allows starting individual containers, checking states, and managing Docker Compose stacks.
- */
-export class DockerManager {
-    private shell: ShellManager;
-    private logger: Logger;
-
-    constructor(shell: ShellManager, logger: Logger) {
-        this.shell = shell;
-        this.logger = logger;
-    }
-
-    /**
-     * @method isRunning
-     * @description Checks whether the Docker service is active and responding on the host system.
-     * @returns {Promise<boolean>} True if Docker is running.
-     * @example
-     * const active = await docker.isRunning();
-     * if (!active) fail('Start Docker first.');
-     */
-    public async isRunning(): Promise<boolean> {
-        try {
-            await this.shell.exec('docker info');
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }
-
-    /**
-     * @method run
-     * @description Deploys an individual container in detached mode. If it already exists, restarts it.
-     * @param {DockerRunOptions} config - Deployment configuration.
-     * @example
-     * await docker.run({ name: 'my-db', image: 'mongo:latest', port: '27017:27017' });
-     */
-    public async run({ image, name, port, env = [] }: DockerRunOptions): Promise<void> {
-        this.logger.info(`Starting container: ${name} (${image})...`);
-        try {
-            if (await this.containerExists(name)) {
-                this.logger.warn(`Container ${name} already exists. Restarting...`);
-                await this.shell.exec(`docker rm -f ${name}`);
-            }
-
-            const envFlags = env.map(e => `-e ${e}`).join(' ');
-            const portMapping = port ? `-p ${port}` : '';
-            const containerId = await this.shell.exec(`docker run -d --name ${name} ${portMapping} ${envFlags} ${image}`);
-            this.logger.success(`Container active. ID: ${containerId.substring(0, 12)}`);
-        } catch (e) {
-            if (e instanceof TyrError) throw e;
-            throw new TyrError(`Could not start container: ${name}`, e, 'Check that Docker is running and the image exists.');
-        }
-    }
-
-    /**
-     * @method containerExists
-     * @description Checks whether a specific container exists (running or stopped).
-     * @param {string} name - The container name to look for.
-     * @returns {Promise<boolean>} True if it exists.
-     * @example
-     * if (await docker.containerExists('my-app')) { ... }
-     */
-    public async containerExists(name: string): Promise<boolean> {
-        try {
-            await this.shell.exec(`docker inspect ${name}`);
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }
-
-    /**
-     * @method composeUp
-     * @description Starts a full stack using a docker-compose file.
-     * @param {string} file - Relative path to the compose file.
-     * @example
-     * await docker.composeUp('infrastructure/db-compose.yml');
-     */
-    public async composeUp(file: string = 'docker-compose.yml'): Promise<void> {
-        this.logger.info(`Starting stack from ${file}...`);
-        try {
-            await this.shell.exec(`docker-compose -f ${file} up -d`);
-            this.logger.success('Stack deployed successfully.');
-        } catch (e) {
-            if (e instanceof TyrError) throw e;
-            throw new TyrError(`Could not start Docker Compose stack from: ${file}`, e, 'Check that the compose file exists and is valid.');
-        }
-    }
-}
-
-export const DockerManagerTests = {
-    // isRunning: {},
-    // run: { image: 'alpine:latest', name: 'tyr-test-container', env: [] },
-    // containerExists: { name: 'tyr-test-container' },
-};
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+export interface DockerRunOptions {
+    image: string;
+    name: string;
+    port?: string;
+    env?: string[];
+}
+
+/**
+ * @class DockerManager
+ * @description Low-level manager for interacting with the Docker Daemon.
+ * Allows starting individual containers, checking states, and managing Docker Compose stacks.
+ */
+export class DockerManager {
+    private shell: ShellManager;
+    private logger: Logger;
+
+    constructor(shell: ShellManager, logger: Logger) {
+        this.shell = shell;
+        this.logger = logger;
+    }
+
+    /**
+     * @method isRunning
+     * @description Checks whether the Docker service is active and responding on the host system.
+     * @returns {Promise<boolean>} True if Docker is running.
+     * @example
+     * const active = await docker.isRunning();
+     * if (!active) fail('Start Docker first.');
+     */
+    public async isRunning(): Promise<boolean> {
+        try {
+            await this.shell.exec('docker info');
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * @method run
+     * @description Deploys an individual container in detached mode. If it already exists, restarts it.
+     * @param {DockerRunOptions} config - Deployment configuration.
+     * @example
+     * await docker.run({ name: 'my-db', image: 'mongo:latest', port: '27017:27017' });
+     */
+    public async run({ image, name, port, env = [] }: DockerRunOptions): Promise<void> {
+        this.logger.info(`Starting container: ${name} (${image})...`);
+        try {
+            if (await this.containerExists(name)) {
+                this.logger.warn(`Container ${name} already exists. Restarting...`);
+                await this.shell.exec(`docker rm -f ${name}`);
+            }
+
+            const envFlags = env.map(e => `-e ${e}`).join(' ');
+            const portMapping = port ? `-p ${port}` : '';
+            const containerId = await this.shell.exec(`docker run -d --name ${name} ${portMapping} ${envFlags} ${image}`);
+            this.logger.success(`Container active. ID: ${containerId.substring(0, 12)}`);
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not start container: ${name}`, e, 'Check that Docker is running and the image exists.');
+        }
+    }
+
+    /**
+     * @method containerExists
+     * @description Checks whether a specific container exists (running or stopped).
+     * @param {string} name - The container name to look for.
+     * @returns {Promise<boolean>} True if it exists.
+     * @example
+     * if (await docker.containerExists('my-app')) { ... }
+     */
+    public async containerExists(name: string): Promise<boolean> {
+        try {
+            await this.shell.exec(`docker inspect ${name}`);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * @method composeUp
+     * @description Starts a full stack using a docker-compose file.
+     * @param {string} file - Relative path to the compose file.
+     * @example
+     * await docker.composeUp('infrastructure/db-compose.yml');
+     */
+    public async composeUp(file: string = 'docker-compose.yml'): Promise<void> {
+        this.logger.info(`Starting stack from ${file}...`);
+        try {
+            await this.shell.exec(`docker-compose -f ${file} up -d`);
+            this.logger.success('Stack deployed successfully.');
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not start Docker Compose stack from: ${file}`, e, 'Check that the compose file exists and is valid.');
+        }
+    }
+}
+
+export const DockerManagerTests = {
+    // isRunning: {},
+    // run: { image: 'alpine:latest', name: 'tyr-test-container', env: [] },
+    // containerExists: { name: 'tyr-test-container' },
+};