@orxataguy/tyr 1.0.11-beta.4 → 1.0.11-beta.9

package/bin/tyr.js

@@ -1,46 +1,28 @@
 #!/usr/bin/env node
-/**
- * bin/tyr.js — Tyr CLI entry point.
- *
- * Spawns Node.js with a custom ESM loader (bin/loader.mjs) that transpiles
- * TypeScript files in-memory using esbuild. This replaces the previous tsx
- * dependency, eliminating all disk-write overhead from TypeScript compilation
- * caches (~/.cache/tsx).
- *
- * Compatibility: Node.js 18+
- * The --loader flag is experimental in Node 22 but fully functional;
- * NODE_NO_WARNINGS suppresses the deprecation notice.
- */
-
-import { fileURLToPath, pathToFileURL } from 'url';
-import { dirname, join } from 'path';
+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 __dirname = dirname(__filename);
+const packageRoot = resolve(__dirname, '..');
 
-const loaderPath = join(__dirname, 'loader.mjs');
-const loaderUrl  = pathToFileURL(loaderPath).href;   // file:// URL — required on Windows
-const entry      = join(__dirname, 'tyr.ts');
+// 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(
-    process.execPath,
-    [
-        '--loader', loaderUrl,
-        '--no-warnings',        // suppress ExperimentalWarning for --loader in Node 22
-        entry,
-        ...process.argv.slice(2),
-    ],
-    {
-        stdio: 'inherit',
-        env: { ...process.env },
-    }
-);
+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)  => {
-    process.stderr.write(`[tyr] Error: Could not start tyr.\n${err.message}\n`);
-    process.stderr.write(`loader path: ${loaderPath}\n`);
-    process.stderr.write('Try reinstalling: npm install -g @orxataguy/tyr\n');
+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: ${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.11-beta.4",
+  "version": "1.0.11-beta.9",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"
@@ -48,13 +48,13 @@
     "chalk": "^5.6.2",
     "cheerio": "^1.1.2",
     "dotenv": "^17.2.3",
-    "esbuild": "^0.25.0",
     "execa": "^6.1.0",
     "find-config": "^1.0.0",
     "inquirer": "^13.2.1",
     "js-yaml": "^4.1.1",
     "mongodb": "^7.2.0",
-    "mssql": "^12.2.0"
+    "mssql": "^12.2.0",
+    "tsx": "^4.21.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
@@ -62,7 +62,6 @@
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "husky": "^9.1.7",
-    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
     "vitest": "^3.2.4"

package/src/core/Kernel.ts

@@ -4,17 +4,16 @@ import yaml from 'js-yaml';
 import dotenv from 'dotenv';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { homedir } from 'os';
-import { Container } from './Container.ts';
+import { Container } from './Container';
 
-import gen   from './sys/gen.ts';
-import rem   from './sys/rem.ts';
-import doc   from './sys/doc.ts';
-import ai    from './sys/ai.ts';
-import build from './sys/build.ts';
-import config from './sys/config.ts';
-import help   from './sys/help.ts';
+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 help from './sys/help';
 
-import { TyrError } from './TyrError.ts';
+import { TyrError } from './TyrError';
 
 interface TyrConfig {
     commands: Record<string, string>;
@@ -46,13 +45,6 @@ export class Kernel {
     private frameworkRoot: string;
     private userRoot: string;
 
-    /**
-     * In-process cache of CommandFactory functions keyed by command name.
-     * Avoids re-importing (and re-transpiling via the ESM loader) the same
-     * module on every run() call within the same process.
-     */
-    private readonly _commandCache = new Map<string, CommandFactory>();
-
     constructor() {
         this.container = new Container();
         this.config = null;
@@ -188,7 +180,6 @@ export class Kernel {
             rem,
             doc,
             ai,
-            build,
         };
 
         if (systemCommands[commandName]) {
@@ -213,37 +204,20 @@ export class Kernel {
         }
 
         try {
-            let commandFactory: CommandFactory;
-
-            if (this._commandCache.has(commandName)) {
-                // Fast path: factory already imported in this process — no I/O at all
-                commandFactory = this._commandCache.get(commandName)!;
-            } else {
-                // Absolute paths (user commands) are used directly; relative paths resolve from frameworkRoot
-                const absolutePath = path.isAbsolute(scriptPath)
-                    ? scriptPath
-                    : path.resolve(this.frameworkRoot, scriptPath);
-
-                // Prefer a pre-compiled JS file produced by `tyr build` (AOT path).
-                // Convention: ~/.tyr/dist/<basename>.js  where basename = original filename with .ts → .js
-                const distFile = path.basename(absolutePath).replace(/\.ts$/, '.js');
-                const distPath = path.join(this.userRoot, 'dist', distFile);
-                const resolvedPath = fs.existsSync(distPath) ? distPath : absolutePath;
-
-                // Convert to file:// URL — required by ESM on Windows for absolute paths
-                const moduleUrl = pathToFileURL(resolvedPath).href;
-                const module = await import(moduleUrl);
-
-                if (typeof module.default !== 'function') {
-                    throw new Error(`File ${scriptPath} does not export a default function.`);
-                }
+            // Absolute paths (user commands) are used directly; relative paths resolve from frameworkRoot
+            const absolutePath = path.isAbsolute(scriptPath)
+                ? scriptPath
+                : path.resolve(this.frameworkRoot, scriptPath);
+
+            // Convert to file:// URL — required by ESM on Windows for absolute paths
+            const moduleUrl = pathToFileURL(absolutePath).href;
+            const module = await import(moduleUrl);
 
-                commandFactory = module.default as CommandFactory;
-                this._commandCache.set(commandName, commandFactory);
+            if (typeof module.default !== 'function') {
+                throw new Error(`File ${scriptPath} does not export a default function.`);
             }
 
-            // Always build a fresh command instance so the context (logger, run, fail…)
-            // reflects the current invocation — important for nested run() calls.
+            const commandFactory: CommandFactory = module.default;
             const command = commandFactory(context);
             await command(args.slice(1));
 

package/src/core/sys/help.ts

@@ -82,7 +82,6 @@ export default function help({ userRoot }: TyrContext) {
             { name: '--update',  description: 'Actualiza ~/.tyr desde el repositorio git.', usage: 'tyr --update' },
             { name: '--upgrade', description: 'Actualiza el paquete npm de tyr.',           usage: 'tyr --upgrade' },
             { name: 'gen',       description: 'Genera un nuevo comando a partir de una descripción con IA.', usage: 'tyr gen <nombre> "<descripción>"' },
-            { name: 'build',     description: 'Compila AOT todos los comandos de map.yml a JS puro (elimina overhead de transpilación en ejecución).', usage: 'tyr build [--clean]' },
             { name: 'doc',       description: 'Levanta la documentación del framework en el navegador.', usage: 'tyr doc' },
         ];
 

package/bin/loader.mjs

@@ -1,98 +0,0 @@
-/**
- * bin/loader.mjs
- *
- * Custom Node.js ESM loader for Tyr.
- * Transpiles TypeScript files on-the-fly using esbuild.transformSync().
- *
- * Key properties:
- *   - Zero disk writes: all transpilation happens in memory — no ~/.cache/tsx or similar
- *   - Fast: esbuild native binary is 50-100× faster than the full TypeScript compiler
- *   - No type-checking: types are stripped, not verified (run tsc --noEmit separately)
- *
- * Registered via --loader flag in bin/tyr.js.
- */
-
-import { transformSync } from 'esbuild';
-import { existsSync, readFileSync } from 'fs';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { resolve as resolvePath, dirname } from 'path';
-
-const TS_RE       = /\.m?[ct]?ts$/;
-const NO_EXT_RE   = /\/[^./]+$/;          // path segment with no extension at the end
-const EXT_MAP     = { '.js': '.ts', '.mjs': '.mts', '.cjs': '.cts' };
-const BARE_EXTS   = ['.ts', '.mts', '.cts', '.js', '.mjs', '/index.ts', '/index.js'];
-
-/**
- * resolve() — handle two TypeScript-in-ESM conventions that Node cannot resolve natively:
- *
- *  1. Extensionless imports:  './Container'  →  './Container.ts'
- *  2. JS-extension imports:   './Foo.js'     →  './Foo.ts'  (TypeScript ESM idiom)
- *
- * Only relative imports are intercepted; bare specifiers (npm packages) go straight
- * to the default resolver.
- */
-export function resolve(specifier, context, next) {
-    if (!specifier.startsWith('.') || !context.parentURL) {
-        return next(specifier, context);
-    }
-
-    const parentDir = dirname(fileURLToPath(context.parentURL));
-    const fullPath  = resolvePath(parentDir, specifier);
-
-    // Case 1: specifier ends with a JS extension — try the equivalent TS extension
-    for (const [jsExt, tsExt] of Object.entries(EXT_MAP)) {
-        if (specifier.endsWith(jsExt)) {
-            const tsPath = fullPath.slice(0, -jsExt.length) + tsExt;
-            if (existsSync(tsPath)) {
-                return { url: pathToFileURL(tsPath).href, shortCircuit: true };
-            }
-        }
-    }
-
-    // Case 2: extensionless — probe TS then JS extensions
-    if (NO_EXT_RE.test(fullPath)) {
-        for (const ext of BARE_EXTS) {
-            const candidate = fullPath + ext;
-            if (existsSync(candidate)) {
-                return { url: pathToFileURL(candidate).href, shortCircuit: true };
-            }
-        }
-    }
-
-    return next(specifier, context);
-}
-
-/**
- * load() — intercept every ESM import whose URL ends in a TypeScript extension.
- *
- * We do NOT exclude node_modules: the tyr package itself ships as .ts source
- * (bin/tyr.ts, src/core/Kernel.ts, etc.) and those files ARE under node_modules
- * when installed globally. Node.js 24's built-in strip-types refuses to handle
- * .ts files under node_modules, so our loader must cover them.
- *
- * The TS_RE regex already limits interception to .ts/.mts/.cts files — the
- * compiled .js files that third-party packages ship will never match it.
- */
-export function load(url, context, next) {
-    const isTs = TS_RE.test(url);
-    if (!isTs) return next(url, context);
-
-    const filePath = fileURLToPath(url);
-    const source   = readFileSync(filePath, 'utf8');
-
-    const { code, warnings } = transformSync(source, {
-        loader:     'ts',
-        format:     'esm',
-        target:     'node18',
-        sourcemap:  'inline',   // inline maps so stack traces point to .ts lines
-        sourcefile: filePath,
-        // Do not inject helpers — keep output minimal
-        treeShaking: false,
-    });
-
-    for (const w of warnings) {
-        process.stderr.write(`[tyr:loader] warning: ${w.text}\n`);
-    }
-
-    return { format: 'module', source: code, shortCircuit: true };
-}

package/src/core/sys/build.ts

@@ -1,121 +0,0 @@
-/**
- * build.ts — sistema: tyr build
- *
- * Compila AOT (Ahead-of-Time) todos los comandos registrados en ~/.tyr/map.yml
- * desde TypeScript a JavaScript puro usando esbuild.
- *
- * El resultado se escribe en ~/.tyr/dist/<basename>.js.
- * Una vez compilado, el Kernel detecta automáticamente los ficheros .js en dist/
- * y los usa en lugar de los .ts originales, eliminando por completo el coste
- * de transpilación en tiempo de ejecución.
- *
- * Uso:
- *   tyr build              — compila todos los comandos de map.yml
- *   tyr build --clean      — elimina ~/.tyr/dist/ antes de compilar
- */
-
-import path from 'path';
-import fs   from 'fs';
-import yaml from 'js-yaml';
-import type { TyrContext } from '../Kernel.js';
-
-interface MapYml {
-    commands: Record<string, string>;
-    aliases?: Record<string, string>;
-}
-
-export default function build({ logger, userRoot }: TyrContext) {
-    return async (args: string[]) => {
-        const clean   = args.includes('--clean');
-        const mapPath = path.join(userRoot, 'map.yml');
-        const distDir = path.join(userRoot, 'dist');
-
-        // ── Leer map.yml ──────────────────────────────────────────────────────
-        if (!fs.existsSync(mapPath)) {
-            logger.error(`No se encontró map.yml en ${userRoot}`);
-            return;
-        }
-
-        const raw = yaml.load(fs.readFileSync(mapPath, 'utf8')) as MapYml;
-        const commands = raw?.commands ?? {};
-        const entries  = Object.entries(commands);
-
-        if (entries.length === 0) {
-            logger.warn('map.yml no contiene comandos. Nada que compilar.');
-            return;
-        }
-
-        // ── Limpiar dist/ si se pide ──────────────────────────────────────────
-        if (clean && fs.existsSync(distDir)) {
-            fs.rmSync(distDir, { recursive: true, force: true });
-            logger.info('dist/ eliminado.');
-        }
-
-        if (!fs.existsSync(distDir)) {
-            fs.mkdirSync(distDir, { recursive: true });
-        }
-
-        // ── Importar esbuild dinámicamente (dep de producción en @orxataguy/tyr) ──
-        // La importación dinámica garantiza que si esbuild no estuviese disponible
-        // se obtiene un error claro en lugar de un crash al arrancar el framework.
-        let esbuild: typeof import('esbuild');
-        try {
-            esbuild = await import('esbuild');
-        } catch {
-            logger.error('esbuild no está disponible. Reinstala: npm install -g @orxataguy/tyr');
-            return;
-        }
-
-        // ── Compilar cada comando ─────────────────────────────────────────────
-        let compiled = 0;
-        let failed   = 0;
-
-        for (const [name, relPath] of entries) {
-            const srcPath = path.isAbsolute(relPath)
-                ? relPath
-                : path.resolve(userRoot, relPath);
-
-            if (!fs.existsSync(srcPath)) {
-                logger.warn(`[${name}] Fichero no encontrado: ${srcPath} — omitido.`);
-                failed++;
-                continue;
-            }
-
-            const outFile = path.join(
-                distDir,
-                path.basename(srcPath).replace(/\.ts$/, '.js'),
-            );
-
-            try {
-                await esbuild.build({
-                    entryPoints: [srcPath],
-                    outfile:     outFile,
-                    bundle:      false,      // solo transpila, no empaqueta deps
-                    platform:    'node',
-                    format:      'esm',
-                    target:      'node18',
-                    sourcemap:   false,      // sin sourcemaps en producción
-                    packages:    'external', // mantiene imports de npm tal cual
-                    logLevel:    'silent',
-                });
-                logger.success(`[${name}] → ${path.relative(userRoot, outFile)}`);
-                compiled++;
-            } catch (err: any) {
-                logger.error(`[${name}] Error de compilación: ${err?.message ?? err}`);
-                failed++;
-            }
-        }
-
-        // ── Resumen ────────────────────────────────────────────────────────────
-        console.log('');
-        if (compiled > 0) {
-            logger.success(
-                `Build completado: ${compiled} comando${compiled !== 1 ? 's' : ''} compilado${compiled !== 1 ? 's' : ''} en dist/`,
-            );
-            logger.info('El Kernel usará automáticamente los ficheros compilados en la próxima ejecución.');
-        }
-        if (failed > 0) {
-            logger.warn(`${failed} comando${failed !== 1 ? 's' : ''} no pudieron compilarse.`);
-        }
-    };
-}