@orxataguy/tyr 1.0.0 → 1.0.2

package/src/lib/FileSystemManager.ts

@@ -1,152 +1,152 @@
-import fs from 'fs/promises';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import path from 'path';
-
-import { Logger } from '../core/Logger.js';
-import { TyrError } from '../core/TyrError.js';
-
-/**
- * @class FileSystemManager
- * @description Abstraction layer over the file system (fs).
- * Includes safety utilities such as automatic backups when overwriting and idempotent writes.
- */
-export class FileSystemManager {
-    private logger: Logger;
-
-    constructor(logger: Logger) {
-        this.logger = logger;
-    }
-
-    private resolvePath(filePath: string): string {
-        return filePath.startsWith('~/')
-            ? path.join(homedir(), filePath.slice(2))
-            : filePath;
-    }
-
-    /**
-     * @method exists
-     * @description Synchronously checks whether a file or directory exists at the given path.
-     * @param {string} filePath - Relative or absolute path to check.
-     * @returns {boolean} True if the file exists.
-     * @example
-     * if (fs.exists('./config.json')) {
-     *   logger.info('Config found.');
-     * }
-     */
-    public exists(filePath: string): boolean {
-        const resolvedPath = this.resolvePath(filePath);
-        return existsSync(resolvedPath);
-    }
-
-    /**
-     * @method read
-     * @description Reads the content of a file in UTF-8 format. Returns null if the file does not exist.
-     * @param {string} filePath - Path to the file.
-     * @returns {Promise<string|null>} File content or null if it does not exist.
-     * @example
-     * const content = await fs.read('.env');
-     */
-    public async read(filePath: string): Promise<string | null> {
-        const resolvedPath = this.resolvePath(filePath);
-        try {
-            return await fs.readFile(resolvedPath, 'utf-8');
-        } catch (e) {
-            if ((e as NodeJS.ErrnoException).code === 'ENOENT') return null;
-            throw new TyrError(`Could not read file: ${filePath}`, e, 'Check that the file exists and has read permissions.');
-        }
-    }
-
-    /**
-     * @method delete
-     * @description Deletes a file if it exists.
-     * @param {string} filePath - Path to the file to delete.
-     * @example
-     * await fs.delete('./temp/cache.log');
-     */
-    public async delete(filePath: string): Promise<void> {
-        const resolvedPath = this.resolvePath(filePath);
-        if (!this.exists(resolvedPath)) {
-            throw new TyrError(`Cannot delete: file not found: ${filePath}`, null, 'Check that the path is correct.');
-        }
-        try {
-            await fs.unlink(resolvedPath);
-            this.logger.success(`File deleted: ${filePath}`);
-        } catch (e) {
-            throw new TyrError(`Could not delete file: ${filePath}`, e);
-        }
-    }
-
-    /**
-     * @method write
-     * @description Writes content to a file. If the file already exists, creates a .bak backup before overwriting.
-     * @param {string} filePath - Destination path.
-     * @param {string} content - Text content to write.
-     * @example
-     * await fs.write('src/config.js', 'export const port = 3000;');
-     */
-    public async write(filePath: string, content: string): Promise<void> {
-        const resolvedPath = this.resolvePath(filePath);
-        try {
-            const dir = path.dirname(resolvedPath);
-            await fs.mkdir(dir, { recursive: true });
-
-            if (this.exists(resolvedPath)) {
-                const backupPath = `${resolvedPath}.bak`;
-                await fs.copyFile(resolvedPath, backupPath);
-                this.logger.info(`Backup created at: ${backupPath}`);
-            }
-
-            await fs.writeFile(resolvedPath, content, 'utf-8');
-            this.logger.success(`File written: ${filePath}`);
-        } catch (e) {
-            if (e instanceof TyrError) throw e;
-            throw new TyrError(`Could not write file: ${filePath}`, e, 'Check write permissions on the destination directory.');
-        }
-    }
-
-    /**
-     * @method createDir
-     * @description Creates a directory recursively (like mkdir -p). Does nothing if it already exists.
-     * @param {string} dirPath - Path of the directory to create.
-     * @example
-     * await fs.createDir('src/controllers/api/v1');
-     */
-    public async createDir(dirPath: string): Promise<void> {
-        const resolvedPath = this.resolvePath(dirPath);
-        if (this.exists(resolvedPath)) return;
-        try {
-            await fs.mkdir(resolvedPath, { recursive: true });
-            this.logger.info(`Directory created: ${dirPath}`);
-        } catch (e) {
-            throw new TyrError(`Could not create directory: ${dirPath}`, e, 'Check write permissions on the parent directory.');
-        }
-    }
-
-    /**
-     * @method ensureLine
-     * @description Ensures that a specific line exists in a file. Useful for adding environment variables or config entries without duplicating them.
-     * @param {string} filePath - Path to the file.
-     * @param {string} line - The exact line to ensure.
-     * @example
-     * await fs.ensureLine('.env', 'PORT=8080');
-     */
-    public async ensureLine(filePath: string, line: string): Promise<void> {
-        const resolvedPath = this.resolvePath(filePath);
-        const content = (await this.read(resolvedPath)) || '';
-        if (content.includes(line)) {
-            this.logger.info(`Line already present in ${filePath}. Skipping.`);
-            return;
-        }
-        const newContent = content.endsWith('\n') ? content + line : content + '\n' + line;
-        await this.write(filePath, newContent);
-    }
-}
-
-export const FileSystemManagerTests = {
-    exists: { filePath: '~/Projects/TyrFramework/package.json' },
-    read:   { filePath: '~/Projects/TyrFramework/package.json' },
-    write:  { filePath: '~/Projects/TyrFramework/tests/foo.test.txt', content: 'Test content from TyrFramework' },
-    delete: { filePath: '~/Projects/TyrFramework/tests/foo.test.txt' },
-    ensureLine: { filePath: '~/Projects/TyrFramework/package.json', line: '"type": "module",' },
-};
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class FileSystemManager
+ * @description Abstraction layer over the file system (fs).
+ * Includes safety utilities such as automatic backups when overwriting and idempotent writes.
+ */
+export class FileSystemManager {
+    private logger: Logger;
+
+    constructor(logger: Logger) {
+        this.logger = logger;
+    }
+
+    private resolvePath(filePath: string): string {
+        return filePath.startsWith('~/')
+            ? path.join(homedir(), filePath.slice(2))
+            : filePath;
+    }
+
+    /**
+     * @method exists
+     * @description Synchronously checks whether a file or directory exists at the given path.
+     * @param {string} filePath - Relative or absolute path to check.
+     * @returns {boolean} True if the file exists.
+     * @example
+     * if (fs.exists('./config.json')) {
+     *   logger.info('Config found.');
+     * }
+     */
+    public exists(filePath: string): boolean {
+        const resolvedPath = this.resolvePath(filePath);
+        return existsSync(resolvedPath);
+    }
+
+    /**
+     * @method read
+     * @description Reads the content of a file in UTF-8 format. Returns null if the file does not exist.
+     * @param {string} filePath - Path to the file.
+     * @returns {Promise<string|null>} File content or null if it does not exist.
+     * @example
+     * const content = await fs.read('.env');
+     */
+    public async read(filePath: string): Promise<string | null> {
+        const resolvedPath = this.resolvePath(filePath);
+        try {
+            return await fs.readFile(resolvedPath, 'utf-8');
+        } catch (e) {
+            if ((e as NodeJS.ErrnoException).code === 'ENOENT') return null;
+            throw new TyrError(`Could not read file: ${filePath}`, e, 'Check that the file exists and has read permissions.');
+        }
+    }
+
+    /**
+     * @method delete
+     * @description Deletes a file if it exists.
+     * @param {string} filePath - Path to the file to delete.
+     * @example
+     * await fs.delete('./temp/cache.log');
+     */
+    public async delete(filePath: string): Promise<void> {
+        const resolvedPath = this.resolvePath(filePath);
+        if (!this.exists(resolvedPath)) {
+            throw new TyrError(`Cannot delete: file not found: ${filePath}`, null, 'Check that the path is correct.');
+        }
+        try {
+            await fs.unlink(resolvedPath);
+            this.logger.success(`File deleted: ${filePath}`);
+        } catch (e) {
+            throw new TyrError(`Could not delete file: ${filePath}`, e);
+        }
+    }
+
+    /**
+     * @method write
+     * @description Writes content to a file. If the file already exists, creates a .bak backup before overwriting.
+     * @param {string} filePath - Destination path.
+     * @param {string} content - Text content to write.
+     * @example
+     * await fs.write('src/config.js', 'export const port = 3000;');
+     */
+    public async write(filePath: string, content: string): Promise<void> {
+        const resolvedPath = this.resolvePath(filePath);
+        try {
+            const dir = path.dirname(resolvedPath);
+            await fs.mkdir(dir, { recursive: true });
+
+            if (this.exists(resolvedPath)) {
+                const backupPath = `${resolvedPath}.bak`;
+                await fs.copyFile(resolvedPath, backupPath);
+                this.logger.info(`Backup created at: ${backupPath}`);
+            }
+
+            await fs.writeFile(resolvedPath, content, 'utf-8');
+            this.logger.success(`File written: ${filePath}`);
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not write file: ${filePath}`, e, 'Check write permissions on the destination directory.');
+        }
+    }
+
+    /**
+     * @method createDir
+     * @description Creates a directory recursively (like mkdir -p). Does nothing if it already exists.
+     * @param {string} dirPath - Path of the directory to create.
+     * @example
+     * await fs.createDir('src/controllers/api/v1');
+     */
+    public async createDir(dirPath: string): Promise<void> {
+        const resolvedPath = this.resolvePath(dirPath);
+        if (this.exists(resolvedPath)) return;
+        try {
+            await fs.mkdir(resolvedPath, { recursive: true });
+            this.logger.info(`Directory created: ${dirPath}`);
+        } catch (e) {
+            throw new TyrError(`Could not create directory: ${dirPath}`, e, 'Check write permissions on the parent directory.');
+        }
+    }
+
+    /**
+     * @method ensureLine
+     * @description Ensures that a specific line exists in a file. Useful for adding environment variables or config entries without duplicating them.
+     * @param {string} filePath - Path to the file.
+     * @param {string} line - The exact line to ensure.
+     * @example
+     * await fs.ensureLine('.env', 'PORT=8080');
+     */
+    public async ensureLine(filePath: string, line: string): Promise<void> {
+        const resolvedPath = this.resolvePath(filePath);
+        const content = (await this.read(resolvedPath)) || '';
+        if (content.includes(line)) {
+            this.logger.info(`Line already present in ${filePath}. Skipping.`);
+            return;
+        }
+        const newContent = content.endsWith('\n') ? content + line : content + '\n' + line;
+        await this.write(filePath, newContent);
+    }
+}
+
+export const FileSystemManagerTests = {
+    exists: { filePath: '~/Projects/TyrFramework/package.json' },
+    read:   { filePath: '~/Projects/TyrFramework/package.json' },
+    write:  { filePath: '~/Projects/TyrFramework/tests/foo.test.txt', content: 'Test content from TyrFramework' },
+    delete: { filePath: '~/Projects/TyrFramework/tests/foo.test.txt' },
+    ensureLine: { filePath: '~/Projects/TyrFramework/package.json', line: '"type": "module",' },
+};

package/src/lib/GitManager.ts

@@ -1,76 +1,76 @@
-import { ShellManager } from './ShellManager.js';
-import { Logger } from '../core/Logger.js';
-import { TyrError } from '../core/TyrError.js';
-
-/**
- * @class GitManager
- * @description Wrapper for common Git operations. Automates repository initialization, commits and cloning.
- */
-export class GitManager {
-    private shell: ShellManager;
-    private logger: Logger;
-
-    constructor(shell: ShellManager, logger: Logger) {
-        this.shell = shell;
-        this.logger = logger;
-    }
-
-    /**
-     * @method init
-     * @description Initializes a Git repository in the current directory and renames the default branch to 'main'.
-     * @example
-     * await git.init();
-     */
-    public async init(): Promise<void> {
-        try { await this.shell.exec('git init'); await this.shell.exec('git branch -M main'); } catch (e) {
-            throw new TyrError(`Could not init git repository`, e, 'Check if the current directory still exists.');
-        }
-    }
-
-    /**
-     * @method addAll
-     * @description Stages all files in the current directory (git add .).
-     * @example
-     * await git.addAll();
-     */
-    public async addAll(): Promise<void> {
-        await this.shell.exec('git add .');
-    }
-
-    /**
-     * @method commit
-     * @description Creates a commit with the provided message.
-     * @param {string} message - The commit message.
-     * @example
-     * await git.commit("feat: initial project structure");
-     */
-    public async commit(message: string): Promise<void> {
-        await this.shell.exec(`git commit -m "${message}"`);
-        this.logger.success(`Commit created: "${message}"`);
-    }
-
-    /**
-     * @method clone
-     * @description Clones a remote repository into the current directory.
-     * @param {string} repoUrl - The HTTPS or SSH URL of the repository.
-     * @example
-     * await git.clone('https://github.com/user/repo.git');
-     */
-    public async clone(repoUrl: string): Promise<void> {
-        this.logger.info(`Cloning ${repoUrl}...`);
-        try {
-            await this.shell.exec(`git clone ${repoUrl}`);
-        } catch (e) {
-            throw new TyrError(`Could not find the repository ` + repoUrl, e, 'Check if the repository exists or if you have the right permissions to clone it.');
-        }
-    }
-}
-
-/**
- * @object GitManagerTests
- * @description Test parameters to validate GitManager functionality.
- */
-export const GitManagerTests = {
-    init: { directory: '/tmp/tyr-git-test' },
-    addAll: { directory: '/tmp/tyr-git-test' },
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class GitManager
+ * @description Wrapper for common Git operations. Automates repository initialization, commits and cloning.
+ */
+export class GitManager {
+    private shell: ShellManager;
+    private logger: Logger;
+
+    constructor(shell: ShellManager, logger: Logger) {
+        this.shell = shell;
+        this.logger = logger;
+    }
+
+    /**
+     * @method init
+     * @description Initializes a Git repository in the current directory and renames the default branch to 'main'.
+     * @example
+     * await git.init();
+     */
+    public async init(): Promise<void> {
+        try { await this.shell.exec('git init'); await this.shell.exec('git branch -M main'); } catch (e) {
+            throw new TyrError(`Could not init git repository`, e, 'Check if the current directory still exists.');
+        }
+    }
+
+    /**
+     * @method addAll
+     * @description Stages all files in the current directory (git add .).
+     * @example
+     * await git.addAll();
+     */
+    public async addAll(): Promise<void> {
+        await this.shell.exec('git add .');
+    }
+
+    /**
+     * @method commit
+     * @description Creates a commit with the provided message.
+     * @param {string} message - The commit message.
+     * @example
+     * await git.commit("feat: initial project structure");
+     */
+    public async commit(message: string): Promise<void> {
+        await this.shell.exec(`git commit -m "${message}"`);
+        this.logger.success(`Commit created: "${message}"`);
+    }
+
+    /**
+     * @method clone
+     * @description Clones a remote repository into the current directory.
+     * @param {string} repoUrl - The HTTPS or SSH URL of the repository.
+     * @example
+     * await git.clone('https://github.com/user/repo.git');
+     */
+    public async clone(repoUrl: string): Promise<void> {
+        this.logger.info(`Cloning ${repoUrl}...`);
+        try {
+            await this.shell.exec(`git clone ${repoUrl}`);
+        } catch (e) {
+            throw new TyrError(`Could not find the repository ` + repoUrl, e, 'Check if the repository exists or if you have the right permissions to clone it.');
+        }
+    }
+}
+
+/**
+ * @object GitManagerTests
+ * @description Test parameters to validate GitManager functionality.
+ */
+export const GitManagerTests = {
+    init: { directory: '/tmp/tyr-git-test' },
+    addAll: { directory: '/tmp/tyr-git-test' },
 };

package/src/lib/PackageManager.ts

@@ -1,87 +1,87 @@
-import { ShellManager } from './ShellManager.js';
-import { Logger } from '../core/Logger.js';
-import { TyrError } from '../core/TyrError.js';
-
-/**
- * @class PackageManager
- * @description OS-agnostic package manager. Automatically detects whether the system uses apt, brew or dnf and installs native software.
- */
-export class PackageManager {
-    private shell: ShellManager;
-    private logger: Logger;
-    private manager: string | null;
-
-    constructor(shell: ShellManager, logger: Logger) {
-        this.shell = shell;
-        this.logger = logger;
-        this.manager = null;
-    }
-
-    /**
-     * @method detect
-     * @description Attempts to identify the package manager installed on the host system.
-     * @returns {Promise<string>} The name of the detected binary ('apt', 'brew', 'dnf').
-     * @example
-     * const mgr = await pkg.detect();
-     * logger.info(`Using: ${mgr}`);
-     */
-    public async detect(): Promise<string> {
-        if (this.manager) return this.manager;
-
-        const isWindows = process.platform === 'win32';
-        const checkCmd = isWindows ? 'where' : 'which';
-
-        const candidates: [string, string][] = isWindows
-            ? [['winget', 'winget'], ['choco', 'choco'], ['scoop', 'scoop']]
-            : [['apt-get', 'apt'], ['brew', 'brew'], ['dnf', 'dnf']];
-
-        for (const [bin, name] of candidates) {
-            try {
-                await this.shell.exec(`${checkCmd} ${bin}`);
-                this.manager = name;
-                return name;
-            } catch (e) {}
-        }
-
-        throw new TyrError(
-            'No supported package manager detected.',
-            null,
-            isWindows
-                ? 'Install winget (Windows Package Manager), Chocolatey, or Scoop.'
-                : 'Make sure apt, brew or dnf is installed on your system.'
-        );
-    }
-
-    /**
-     * @method install
-     * @description Installs a system package using the detected package manager.
-     * @param {string} packageName - Name of the package to install (e.g. 'nginx', 'python3').
-     * @example
-     * await pkg.install('nginx');
-     */
-    public async install(packageName: string): Promise<void> {
-        const mgr = await this.detect();
-        this.logger.info(`Installing ${packageName} using ${mgr}...`);
-
-        const commands: Record<string, string> = {
-            apt: `sudo apt-get install -y ${packageName}`,
-            brew: `brew install ${packageName}`,
-            dnf: `sudo dnf install -y ${packageName}`,
-            winget: `winget install ${packageName}`,
-            choco: `choco install -y ${packageName}`,
-            scoop: `scoop install ${packageName}`,
-        };
-
-        try {
-            await this.shell.exec(commands[mgr]);
-            this.logger.success(`Package ${packageName} installed.`);
-        } catch (e) {
-            if (e instanceof TyrError) throw e;
-            throw new TyrError(`Could not install package: ${packageName}`, e, `Try running the install command manually with ${mgr}.`);
-        }
-    }
-}
-
-export const PackageManagerTests = {
-    detect: {},
-};
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class PackageManager
+ * @description OS-agnostic package manager. Automatically detects whether the system uses apt, brew or dnf and installs native software.
+ */
+export class PackageManager {
+    private shell: ShellManager;
+    private logger: Logger;
+    private manager: string | null;
+
+    constructor(shell: ShellManager, logger: Logger) {
+        this.shell = shell;
+        this.logger = logger;
+        this.manager = null;
+    }
+
+    /**
+     * @method detect
+     * @description Attempts to identify the package manager installed on the host system.
+     * @returns {Promise<string>} The name of the detected binary ('apt', 'brew', 'dnf').
+     * @example
+     * const mgr = await pkg.detect();
+     * logger.info(`Using: ${mgr}`);
+     */
+    public async detect(): Promise<string> {
+        if (this.manager) return this.manager;
+
+        const isWindows = process.platform === 'win32';
+        const checkCmd = isWindows ? 'where' : 'which';
+
+        const candidates: [string, string][] = isWindows
+            ? [['winget', 'winget'], ['choco', 'choco'], ['scoop', 'scoop']]
+            : [['apt-get', 'apt'], ['brew', 'brew'], ['dnf', 'dnf']];
+
+        for (const [bin, name] of candidates) {
+            try {
+                await this.shell.exec(`${checkCmd} ${bin}`);
+                this.manager = name;
+                return name;
+            } catch (e) {}
+        }
+
+        throw new TyrError(
+            'No supported package manager detected.',
+            null,
+            isWindows
+                ? 'Install winget (Windows Package Manager), Chocolatey, or Scoop.'
+                : 'Make sure apt, brew or dnf is installed on your system.'
+        );
+    }
+
+    /**
+     * @method install
+     * @description Installs a system package using the detected package manager.
+     * @param {string} packageName - Name of the package to install (e.g. 'nginx', 'python3').
+     * @example
+     * await pkg.install('nginx');
+     */
+    public async install(packageName: string): Promise<void> {
+        const mgr = await this.detect();
+        this.logger.info(`Installing ${packageName} using ${mgr}...`);
+
+        const commands: Record<string, string> = {
+            apt: `sudo apt-get install -y ${packageName}`,
+            brew: `brew install ${packageName}`,
+            dnf: `sudo dnf install -y ${packageName}`,
+            winget: `winget install ${packageName}`,
+            choco: `choco install -y ${packageName}`,
+            scoop: `scoop install ${packageName}`,
+        };
+
+        try {
+            await this.shell.exec(commands[mgr]);
+            this.logger.success(`Package ${packageName} installed.`);
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not install package: ${packageName}`, e, `Try running the install command manually with ${mgr}.`);
+        }
+    }
+}
+
+export const PackageManagerTests = {
+    detect: {},
+};