@orxataguy/tyr 1.0.0 → 1.0.2

package/src/core/Kernel.ts

@@ -1,165 +1,213 @@
-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 dotenv from 'dotenv';
+import { fileURLToPath, pathToFileURL } 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');
+
+        // Load all env vars from ~/.tyr/.env once, before anything else
+        (dotenv as any).config({ path: path.join(this.userRoot, '.env'), quiet: true });
+
+        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)(args.slice(1));
+            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);
+
+            // Convert to file:// URL — required by ESM on Windows for absolute paths
+            const moduleUrl = pathToFileURL(absolutePath).href;
+            const module = await import(moduleUrl);
+
+            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

@@ -1,48 +1,51 @@
-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`);
+
+    const writeToFile = (level: string, msg: any) => {
+        try {
+            fs.mkdirSync(logDir, { recursive: true });
+            const timestamp = new Date().toISOString();
+            const line = `[${timestamp}] [${level}] ${String(msg)}\n`;
+            fs.appendFileSync(logFile, line, 'utf-8');
+        } catch {
+            // Logging failures must never crash the application
+        }
+    };
+
+    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)');
+        }
+    }
+}