@orxataguy/tyr 1.0.4 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"
@@ -10,8 +10,7 @@
   },
   "files": [
     "bin/",
-    "src/",
-    "config/"
+    "src/"
   ],
   "scripts": {
     "test": "vitest run",

package/src/core/Container.ts

@@ -6,6 +6,8 @@ import { GitManager } from '../lib/GitManager.js';
 import { SystemManager } from '../lib/SystemManager.js';
 import { SQLManager } from '../lib/SQLManager.js';
 import { WebManager } from '../lib/WebManager.js';
+import { WorkspaceManager } from '../lib/WorkspaceManager.js';
+import { JiraManager } from '../lib/JiraManager.js';
 import { Logger, createLogger } from './Logger.js';
 
 export type { Logger };
@@ -20,6 +22,8 @@ export interface ServiceContainer {
     sys: SystemManager;
     db: SQLManager;
     web: WebManager;
+    workspace: WorkspaceManager;
+    jira: JiraManager;
 }
 
 export class Container {
@@ -33,17 +37,21 @@ export class Container {
         const logger = createLogger(isDebug);
         const shell = new ShellManager();
         const db = new SQLManager();
+        const web = new WebManager(logger);
+        const fs = new FileSystemManager(logger);
 
         this.services = {
             logger,
             shell,
             db,
-            web: new WebManager(logger),
-            fs: new FileSystemManager(logger),
+            web,
+            fs,
             pkg: new PackageManager(shell, logger),
             docker: new DockerManager(shell, logger),
             git: new GitManager(shell, logger),
             sys: new SystemManager(shell, logger),
+            workspace: new WorkspaceManager(shell, fs, logger),
+            jira: new JiraManager(web, shell, logger),
         };
     }
 

package/src/core/Kernel.ts

@@ -86,7 +86,8 @@ export class Kernel {
             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');
+            console.log('       tyr --update     Pull latest changes from the linked ~/.tyr repo');
+            console.log('       tyr --upgrade    Upgrade Tyr to the latest npm version');
             return;
         }
 
@@ -98,14 +99,30 @@ export class Kernel {
             return;
         }
 
-        // --update
+        // --update: pull latest changes from the linked ~/.tyr git repo
         if (commandName === '--update') {
+            const shell = this.container.get().shell;
+            const gitDir = path.join(this.userRoot, '.git');
+            if (!fs.existsSync(gitDir)) {
+                console.log('~/.tyr no está vinculado a ningún repositorio git.');
+                console.log('Ejecuta: tyr --config --repo <url>  para vincularlo.');
+                return;
+            }
+            console.log('Actualizando ~/.tyr desde el repositorio...');
+            shell.cd(this.userRoot);
+            await shell.exec('git pull');
+            console.log('Actualización completada.');
+            return;
+        }
+
+        // --upgrade: update the Tyr npm package itself
+        if (commandName === '--upgrade') {
             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}...`);
+            console.log(`Actualizando ${pkg.name}...`);
             await shell.exec(`npm update -g ${pkg.name}`);
-            console.log('Update complete. Run tyr --version to confirm.');
+            console.log('Actualización completada. Ejecuta tyr --version para confirmar.');
             return;
         }
 

package/src/core/sys/ai.ts

@@ -111,7 +111,7 @@ REGLAS:export default;async(args:string[]);task() p/errores;fail() p/validar;Tes
 Responde SOLO código TS sin explicaciones ni backticks.`;
 }
 
-export default function ai({ logger, fs: tyrFs, frameworkRoot, run, fail }: TyrContext) {
+export default function ai({ logger, fs: tyrFs, userRoot, run, fail }: TyrContext) {
     return async (args: string[]) => {
         const commandName = args[0];
         const prompt = args.slice(1).join(' ');
@@ -153,8 +153,8 @@ export default function ai({ logger, fs: tyrFs, frameworkRoot, run, fail }: TyrC
             );
         }
 
-        const filePath = path.resolve(frameworkRoot, 'src/commands', `${commandName}.tyr.ts`);
+        const filePath = path.join(userRoot, 'commands', `${commandName}.tyr.ts`);
         await tyrFs.write(filePath, code);
-        logger.success(`'${commandName}' -> src/commands/${commandName}.tyr.ts`);
+        logger.success(`'${commandName}' -> ~/.tyr/commands/${commandName}.tyr.ts`);
     };
 }

package/src/core/sys/config.ts

@@ -59,6 +59,33 @@ function detectShellRcFile(homeDir: string): string | null {
     return fallbacks.find(p => existsSync(p)) ?? path.join(homeDir, '.bashrc');
 }
 
+const PACKAGE_JSON_TEMPLATE = `{
+  "name": "tyr-commands",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true,
+  "description": "Comandos personalizados de Tyr (~/.tyr/)",
+  "dependencies": {
+    "@orxataguy/tyr": "latest"
+  }
+}
+`;
+
+const TSCONFIG_TEMPLATE = `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["commands/**/*.ts"]
+}
+`;
+
 const ENV_TEMPLATE = `# ~/.tyr/.env
 # Variables de entorno para Tyr. Este archivo nunca debe subirse a git.
 #
@@ -220,6 +247,27 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
                 logger.success(`Archivo creado: ${envPath}`);
             }
 
+            const packageJsonPath = path.join(userRoot, 'package.json');
+            if (!tyrFs.exists(packageJsonPath)) {
+                await tyrFs.write(packageJsonPath, PACKAGE_JSON_TEMPLATE);
+                logger.success(`Archivo creado: ${packageJsonPath}`);
+            }
+
+            const tsconfigPath = path.join(userRoot, 'tsconfig.json');
+            if (!tyrFs.exists(tsconfigPath)) {
+                await tyrFs.write(tsconfigPath, TSCONFIG_TEMPLATE);
+                logger.success(`Archivo creado: ${tsconfigPath}`);
+            }
+
+            logger.info('\nInstalando dependencias de tipos en ~/.tyr...');
+            shell.cd(userRoot);
+            try {
+                await shell.exec('npm install');
+                logger.success('Dependencias instaladas correctamente.');
+            } catch {
+                logger.warn('No se pudo ejecutar npm install en ~/.tyr. Hazlo manualmente.');
+            }
+
             if (repoUrl) {
                 logger.info('\nSubiendo configuración inicial al repositorio...');
                 shell.cd(userRoot);
@@ -234,6 +282,35 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
             }
         }
 
+        // Garantizar package.json + tsconfig.json + npm install siempre,
+        // tanto en init fresh como al clonar un repo existente.
+        const packageJsonPath = path.join(userRoot, 'package.json');
+        const tsconfigPath    = path.join(userRoot, 'tsconfig.json');
+        let needsInstall = false;
+
+        if (!tyrFs.exists(packageJsonPath)) {
+            await tyrFs.write(packageJsonPath, PACKAGE_JSON_TEMPLATE);
+            logger.success(`Archivo creado: ${packageJsonPath}`);
+            needsInstall = true;
+        }
+
+        if (!tyrFs.exists(tsconfigPath)) {
+            await tyrFs.write(tsconfigPath, TSCONFIG_TEMPLATE);
+            logger.success(`Archivo creado: ${tsconfigPath}`);
+            needsInstall = true;
+        }
+
+        if (needsInstall) {
+            logger.info('\nInstalando dependencias de tipos en ~/.tyr...');
+            shell.cd(userRoot);
+            try {
+                await shell.exec('npm install');
+                logger.success('Dependencias instaladas.');
+            } catch {
+                logger.warn('No se pudo ejecutar npm install en ~/.tyr. Hazlo manualmente.');
+            }
+        }
+
         const aliasesPath = path.join(userRoot, `aliases${ext}`);
         const pluginsPath = path.join(userRoot, `plugins${ext}`);
 

package/src/core/sys/doc.ts

@@ -304,7 +304,7 @@ if (!fs.existsSync('./package.json')) {
                         await run('ai', [name, prompt]);
 
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ success: true, message: `Comando '${name}' generado correctamente en src/commands/${name}.tyr.ts` }));
+                        res.end(JSON.stringify({ success: true, message: `Comando '${name}' generado correctamente en ~/.tyr/commands/${name}.tyr.ts` }));
                     } catch (e: any) {
                         res.writeHead(500, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ success: false, message: e.message || 'Error al generar el comando.' }));

package/src/lib/FileSystemManager.ts

@@ -19,9 +19,28 @@ export class FileSystemManager {
     }
 
     private resolvePath(filePath: string): string {
-        return filePath.startsWith('~/')
-            ? path.join(homedir(), filePath.slice(2))
-            : filePath;
+        return this.expandPath(filePath);
+    }
+
+    /**
+     * @method expandPath
+     * @description Expands `~` and `$HOME` in a path string to the actual home directory.
+     * Useful for reading paths from environment variables (dotenv does not expand shell variables).
+     * @param {string} filePath - The path to expand.
+     * @returns {string} The expanded absolute path.
+     * @example
+     * const dir = fs.expandPath(process.env.INTEGRATIONS_DIR!);
+     * // "~/dev/datosBroker" → "/Users/mandreu/dev/datosBroker"
+     */
+    public expandPath(filePath: string): string {
+        const home = homedir();
+        if (filePath.startsWith('~/') || filePath === '~') {
+            return path.join(home, filePath.slice(1));
+        }
+        if (filePath.startsWith('$HOME/') || filePath === '$HOME') {
+            return path.join(home, filePath.slice(5));
+        }
+        return filePath;
     }
 
     /**

package/src/lib/GitManager.ts

@@ -64,6 +64,65 @@ export class GitManager {
             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.');
         }
     }
+
+    /**
+     * @method cloneTo
+     * @description Clones a remote repository into a specific target directory.
+     * @param {string} repoUrl - The HTTPS or SSH URL of the repository.
+     * @param {string} destDir - The absolute path of the destination directory.
+     * @example
+     * await git.cloneTo('git@github.com:org/repo.git', '/path/to/dest');
+     */
+    public async cloneTo(repoUrl: string, destDir: string): Promise<void> {
+        this.logger.info(`Clonando ${repoUrl}...`);
+        const loader = this.shell.showLoader('Clonando repositorio...');
+        try {
+            await this.shell.exec(`git clone "${repoUrl}" "${destDir}"`);
+            await this.shell.exec(`git -C "${destDir}" config --add core.filemode false`);
+            loader.stop();
+            this.logger.success('Clonación completada.');
+        } catch (e) {
+            loader.stop();
+            throw new TyrError(`No se pudo clonar el repositorio: ${repoUrl}`, e, 'Comprueba que el repositorio existe y que tienes permisos para clonarlo.');
+        }
+    }
+
+    /**
+     * @method checkRepoExists
+     * @description Checks if a remote Git repository is accessible via ls-remote.
+     * @param {string} repoUrl - The URL of the repository to check.
+     * @returns {Promise<boolean>} True if the repository is reachable.
+     * @example
+     * const exists = await git.checkRepoExists('git@github.com:org/repo.git');
+     */
+    public async checkRepoExists(repoUrl: string): Promise<boolean> {
+        try {
+            await this.shell.exec(`git ls-remote "${repoUrl}" HEAD`);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * @method initWithRemote
+     * @description Removes an existing .git folder if present, then initialises a new Git repository
+     * in the given directory and configures a remote origin.
+     * @param {string} dir - The absolute path of the directory to initialise.
+     * @param {string} remoteUrl - The remote URL to set as origin.
+     * @example
+     * await git.initWithRemote('/path/to/dir', 'git@github.com:org/repo.git');
+     */
+    public async initWithRemote(dir: string, remoteUrl: string): Promise<void> {
+        try {
+            await this.shell.exec(
+                `cd "${dir}" && rm -rf .git && git init -b master && git remote add origin "${remoteUrl}" && git config --add core.filemode false && echo 'node_modules' >> .gitignore`
+            );
+            this.logger.success(`Repositorio Git inicializado en ${dir}`);
+        } catch (e) {
+            throw new TyrError(`No se pudo inicializar el repositorio en ${dir}`, e);
+        }
+    }
 }
 
 /**

package/src/lib/JiraManager.ts

@@ -0,0 +1,103 @@
+import { WebManager } from './WebManager.js';
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+
+interface JiraIssue {
+    key: string;
+    summary: string;
+    status: string;
+}
+
+/**
+ * @class JiraManager
+ * @description Integration with the Jira REST API. Allows fetching and selecting issues
+ * assigned to the current user. Falls back to manual branch input if Jira is unavailable.
+ *
+ * Required environment variables:
+ *   JIRA_URL   – e.g. https://yourcompany.atlassian.net
+ *   JIRA_TOKEN – base64 of "email:api_token" (Basic Auth)
+ */
+export class JiraManager {
+    private web: WebManager;
+    private shell: ShellManager;
+    private logger: Logger;
+
+    constructor(web: WebManager, shell: ShellManager, logger: Logger) {
+        this.web = web;
+        this.shell = shell;
+        this.logger = logger;
+    }
+
+    private get jiraUrl(): string | undefined {
+        return process.env.JIRA_URL;
+    }
+
+    private get jiraToken(): string | undefined {
+        return process.env.JIRA_TOKEN;
+    }
+
+    private async fetchMyIssues(): Promise<JiraIssue[]> {
+        if (!this.jiraUrl || !this.jiraToken) return [];
+
+        const jql = 'assignee = currentUser() AND status IN ("To develop","TO BE DONE",Backlog,"Pending Info",Developing,DEVELOPMENT,"In development",TEST,DESIGN,"To Do","In Progress")';
+        const url = `${this.jiraUrl}/rest/api/3/search?jql=${encodeURIComponent(jql)}`;
+
+        const data = await this.web.get(url, {
+            headers: { Authorization: `Basic ${this.jiraToken}` },
+        });
+
+        return (data.issues ?? []).map((issue: any) => ({
+            key: issue.key,
+            summary: issue.fields.summary,
+            status: issue.fields.status.name,
+        }));
+    }
+
+    /**
+     * @method selectIssue
+     * @description Presents the user's open Jira issues as an interactive list and returns
+     * the selected issue key (e.g. "PROJ-123"). If Jira is not configured or unreachable,
+     * falls back to a free-text prompt for a branch name.
+     * Returns null if the user chooses to skip.
+     * @returns {Promise<string | null>} The selected Jira key, a branch name, or null.
+     * @example
+     * const branch = await jira.selectIssue();
+     * if (branch) await workspace.tagWorkspace(dir, branch);
+     */
+    public async selectIssue(): Promise<string | null> {
+        // Try Jira API
+        if (this.jiraUrl && this.jiraToken) {
+            try {
+                const issues = await this.fetchMyIssues();
+                const choices = [
+                    ...issues.map(i => ({
+                        name: `${i.key} - ${i.summary} [${i.status}]`,
+                        value: i.key,
+                    })),
+                    { name: 'Sin ticket (introducir rama manualmente)', value: '__manual__' },
+                    { name: 'Omitir (no crear rama)', value: '__skip__' },
+                ];
+
+                const selected = await this.shell.select(choices, 'Selecciona un ticket de Jira:');
+
+                if (selected === '__skip__') return null;
+                if (selected === '__manual__') return this.askForBranch();
+
+                return selected;
+            } catch {
+                this.logger.warn('No se ha podido conectar con Jira. Introducción manual de rama.');
+            }
+        }
+
+        return this.askForBranch();
+    }
+
+    private async askForBranch(): Promise<string | null> {
+        const raw = await this.shell.input('Introduce el nombre de la nueva rama (vacío para omitir):');
+        if (!raw.trim()) return null;
+        // Normalise: take the last segment separated by '/'
+        return raw.trim().split('/').pop()?.toUpperCase() ?? raw.trim();
+    }
+}
+
+export const JiraManagerTests = {};

package/src/lib/ShellManager.ts

@@ -104,6 +104,86 @@ export class ShellManager {
 
         this.cwd = resolve(this.cwd, expandedPath);
     }
+
+    /**
+     * @method getCwd
+     * @description Returns the current working directory used by this instance.
+     * @returns {string} The current working directory.
+     * @example
+     * const dir = shell.getCwd();
+     */
+    public getCwd(): string {
+        return this.cwd;
+    }
+
+    /**
+     * @method confirm
+     * @description Prompts the user with a yes/no question via CLI.
+     * @param {string} question - The question to display.
+     * @param {boolean} defaultValue - Default answer if user presses Enter (default: false).
+     * @returns {Promise<boolean>} True if the user confirmed.
+     * @example
+     * const ok = await shell.confirm('¿Continuar?', false);
+     */
+    public async confirm(question: string, defaultValue: boolean = false): Promise<boolean> {
+        try {
+            const result = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'value',
+                message: question,
+                default: defaultValue,
+            }]);
+            return result.value;
+        } catch (e) {
+            throw new TyrError(`Error al mostrar la confirmación: ${question}`, e);
+        }
+    }
+
+    /**
+     * @method select
+     * @description Prompts the user to select one option from a list.
+     * @param {Array<{name: string, value: string}>} choices - The available options.
+     * @param {string} question - The question to display.
+     * @returns {Promise<string>} The selected value.
+     * @example
+     * const branch = await shell.select([{ name: 'main', value: 'main' }], '¿Qué rama?');
+     */
+    public async select(choices: { name: string; value: string }[], question: string): Promise<string> {
+        try {
+            const result = await inquirer.prompt([{
+                type: 'list',
+                name: 'value',
+                message: question,
+                choices,
+            }]);
+            return result.value;
+        } catch (e) {
+            throw new TyrError(`Error al mostrar la selección: ${question}`, e);
+        }
+    }
+
+    /**
+     * @method checkbox
+     * @description Prompts the user to select multiple options from a list.
+     * @param {Array<{name: string, value: string}>} choices - The available options.
+     * @param {string} question - The question to display.
+     * @returns {Promise<string[]>} The selected values.
+     * @example
+     * const widgets = await shell.checkbox(choices, '¿Qué widgets incluir?');
+     */
+    public async checkbox(choices: { name: string; value: string }[], question: string): Promise<string[]> {
+        try {
+            const result = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'value',
+                message: question,
+                choices,
+            }]);
+            return result.value;
+        } catch (e) {
+            throw new TyrError(`Error al mostrar las opciones: ${question}`, e);
+        }
+    }
 }
 
 /**
@@ -114,5 +194,8 @@ export const ShellManagerTests = {
     exec: { command: 'node -v' },
     cd: { path: '/tmp' },
     input: { question: 'Enter a test value:' },
-    showLoader: { message: 'Loading test...' }
+    showLoader: { message: 'Loading test...' },
+    confirm: { question: '¿Continuar?', defaultValue: false },
+    select: { choices: [{ name: 'Opción A', value: 'a' }, { name: 'Opción B', value: 'b' }], question: '¿Cuál eliges?' },
+    checkbox: { choices: [{ name: 'Item 1', value: '1' }, { name: 'Item 2', value: '2' }], question: '¿Cuáles quieres?' },
 };

package/src/lib/WebManager.ts

@@ -24,6 +24,46 @@ export class WebManager {
         }
     }
 
+    /**
+     * @method get
+     * @description Makes an HTTP GET request and returns the raw response data. Useful for REST APIs.
+     * @param {string} url - The URL to request.
+     * @param {AxiosRequestConfig} config - Optional Axios config (headers, params, etc.).
+     * @returns {Promise<any>} The response data.
+     * @example
+     * const data = await web.get('https://api.example.com/items', { headers: { Authorization: 'Bearer token' } });
+     */
+    public async get(url: string, config?: AxiosRequestConfig): Promise<any> {
+        try {
+            const response = await axios.get(url, config);
+            return response.data;
+        } catch (e: any) {
+            const status = e?.response?.status;
+            const err = new TyrError(`HTTP GET failed (${status ?? 'unknown'}): ${url}`, e, 'Check your network connection and the URL.');
+            (err as any).status = status;
+            throw err;
+        }
+    }
+
+    /**
+     * @method getMetaTag
+     * @description Fetches a page and returns the content of a specific meta tag.
+     * @param {string} url - The URL of the page to scrape.
+     * @param {string} metaName - The name attribute of the meta tag.
+     * @returns {Promise<string|null>} The content of the meta tag, or null if not found.
+     * @example
+     * const webname = await web.getMetaTag('https://client.example.com', 'webname');
+     */
+    public async getMetaTag(url: string, metaName: string): Promise<string | null> {
+        try {
+            const $ = await this.fetch(url);
+            return $(`meta[name="${metaName}"]`).attr('content') ?? null;
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not read meta tag '${metaName}' from: ${url}`, e);
+        }
+    }
+
     /**
      * @method selectFromWeb
      * @description Selects elements from a web page using a CSS selector.

package/src/lib/WorkspaceManager.ts

@@ -0,0 +1,87 @@
+import { ShellManager } from './ShellManager.js';
+import { FileSystemManager } from './FileSystemManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class WorkspaceManager
+ * @description Manages local workspace directories: checks for existing repos,
+ * creates branches and opens the project in VSCode.
+ */
+export class WorkspaceManager {
+    private shell: ShellManager;
+    private fs: FileSystemManager;
+    private logger: Logger;
+
+    constructor(shell: ShellManager, fs: FileSystemManager, logger: Logger) {
+        this.shell = shell;
+        this.fs = fs;
+        this.logger = logger;
+    }
+
+    /**
+     * @method checkExisting
+     * @description Checks whether a workspace directory already exists.
+     * If it does, asks the user if they want to replace it (deleting it first).
+     * Returns true if the caller should proceed with creating the workspace.
+     * @param {string} dirPath - Absolute path to the workspace directory.
+     * @param {string} type - Human-readable type name shown in messages (e.g. 'integración', 'web').
+     * @returns {Promise<boolean>} True if the workspace can be created/overwritten.
+     * @example
+     * const proceed = await workspace.checkExisting('/path/to/repo', 'integración');
+     * if (!proceed) return;
+     */
+    public async checkExisting(dirPath: string, type: string = 'directorio'): Promise<boolean> {
+        if (!this.fs.exists(dirPath)) return true;
+
+        this.logger.warn(`Este ${type} ya existe: ${dirPath}`);
+        const replace = await this.shell.confirm('¿Quieres reemplazarlo?', false);
+
+        if (!replace) {
+            this.logger.info('Operación cancelada.');
+            return false;
+        }
+
+        try {
+            await this.shell.exec(`rm -rf "${dirPath}"`);
+            this.logger.info('Directorio existente eliminado.');
+            return true;
+        } catch (e) {
+            throw new TyrError(`No se pudo eliminar el directorio existente: ${dirPath}`, e);
+        }
+    }
+
+    /**
+     * @method tagWorkspace
+     * @description Tags a workspace by creating and checking out a new Git branch,
+     * and optionally opening it in VSCode.
+     * @param {string} dir - Absolute path to the workspace directory.
+     * @param {string | null} branch - Branch name to create (null = skip branch creation).
+     * @param {boolean} openCode - Whether to open the directory in VSCode (default: true).
+     * @example
+     * await workspace.tagWorkspace('/path/to/repo', 'PROJ-123', true);
+     */
+    public async tagWorkspace(dir: string, branch: string | null, openCode: boolean = true): Promise<void> {
+        if (branch) {
+            try {
+                await this.shell.exec(`git -C "${dir}" checkout -b ${branch}`);
+                this.logger.success(`Rama '${branch}' creada.`);
+            } catch (e) {
+                this.logger.warn(`No se pudo crear la rama '${branch}'. Puede que ya exista.`);
+            }
+        }
+
+        if (openCode) {
+            try {
+                await this.shell.exec(`code "${dir}"`);
+            } catch {
+                this.logger.warn('No se pudo abrir VSCode. Asegúrate de tener el comando "code" instalado.');
+            }
+        }
+    }
+}
+
+export const WorkspaceManagerTests = {
+    checkExisting: { dirPath: '/tmp/tyr-workspace-test', type: 'integración' },
+    tagWorkspace: { dir: '/tmp/tyr-workspace-test', branch: null, openCode: false },
+};

package/config/map.yml

@@ -1,4 +0,0 @@
-settings:
-  appName: Tyr CLI
-  version: 0.1.0
-commands: {}

package/src/commands/di.tyr.ts

@@ -1,113 +0,0 @@
-import { TyrContext } from '../core/Kernel';
-
-export default ({ task, fail, logger, shell, db, git, fs }: TyrContext) => {
-    /**
-     * @method extractBranchName
-     * @description Extrae el nombre de rama de una URL o devuelve el nombre tal cual
-     */
-    const extractBranchName = (input: string): string => {
-        if (input.includes('/')) {
-            const parts = input.split('/');
-            return parts[parts.length - 1];
-        }
-        return input;
-    };
-
-    return async (args: string[]) => {
-
-        // Validación de argumentos
-        if (args.length === 0) {
-            fail(
-                'No se especificó la URL del cliente',
-                'Uso: clone-client <url-cliente> [url-rama-opcional]'
-            );
-        }
-
-        const clientUrl = args[0];
-        const branchUrlOrName = args[1] || null;
-
-        logger.info('Navegando al directorio de clientes...');
-        shell.cd('~/dev/wolbenvironment/dev/online-booking/htdocs/datosBroker');
-
-        const broker = await task('Buscando broker en la base de datos', async () => {
-            const result = await db.searchBrokerOnDB(clientUrl);
-
-            if (!result) {
-                fail(
-                    `No se encontró broker para la URL: ${clientUrl}`,
-                    'Verifica que la URL sea correcta y esté registrada en la BD'
-                );
-            }
-
-            logger.success(`Broker encontrado: ${result}`);
-            return result;
-        });
-
-        const brokerPath = `~/dev/wolbenvironment/dev/online-booking/htdocs/datosBroker/${broker}`;
-        const dirExists = fs.exists(brokerPath);
-
-        if (dirExists) {
-            logger.warn(`El directorio '${broker}' ya existe`);
-
-            const choice = await shell.input(
-                '¿Qué deseas hacer? (s)obrescribir / (m)antener / (r)enombrar: '
-            );
-
-            if (choice.toLowerCase() === 'm' || choice.toLowerCase() === 'mantener') {
-                logger.info('Manteniendo directorio existente. Finalizando...');
-                return;
-            } else if (choice.toLowerCase() === 'r' || choice.toLowerCase() === 'renombrar') {
-                await task('Renombrando directorio existente', async () => {
-                    await shell.exec(`mv ${broker} ${broker}.bak`);
-                    logger.success(`Directorio renombrado a: ${broker}.bak`);
-                });
-            } else if (choice.toLowerCase() === 's' || choice.toLowerCase() === 'sobrescribir') {
-                await task('Eliminando directorio existente', async () => {
-                    await shell.exec(`rm -rf ${broker}`);
-                    logger.success('Directorio eliminado');
-                });
-            } else {
-                fail('Opción no válida', 'Usa: s (sobrescribir), m (mantener) o r (renombrar)');
-            }
-        }
-
-        const repoUrl = `git@github.com:Avantio/${broker}`;
-        logger.info(`Repositorio: ${repoUrl}`);
-
-        const loader = shell.showLoader('Clonando repositorio desde GitHub...');
-
-        await task('Clonando repositorio', async () => {
-            await git.clone(repoUrl);
-            loader.stop();
-            logger.success('Repositorio clonado exitosamente');
-        }, false, () => loader.stop());
-
-        shell.cd(broker);
-
-        let branchName: string;
-
-        if (branchUrlOrName) {
-            branchName = extractBranchName(branchUrlOrName);
-            logger.info(`Rama extraída: ${branchName}`);
-        } else {
-            const answer = await shell.input('🌿 ¿Qué rama quieres usar? (nombre o URL): ');
-            branchName = extractBranchName(answer);
-        }
-
-        await task(`Cambiando a la rama: ${branchName}`, async () => {
-            if (branchName.length > 0) {
-                await shell.exec(`git checkout -b ${branchName}`);
-                logger.success(`Ahora estás en la rama: ${branchName}`);
-            } else {
-                logger.info('No se va a generar ninguna rama nueva')
-            }
-        });
-        logger.success(`Repositorio ${broker} clonado y configurado exitosamente`);
-
-    };
-};
-
-
-// export const Test = {
-//     args: []
-// }

package/src/commands/dw.tyr.ts

@@ -1,116 +0,0 @@
-import { TyrContext } from '../core/Kernel';
-
-export default ({ task, fail, logger, shell, db, git, fs }: TyrContext) => {
-    /**
-     * @method extractBranchName
-     * @description Extrae el nombre de rama de una URL o devuelve el nombre tal cual
-     */
-    const extractBranchName = (input: string): string => {
-        if (input.includes('/')) {
-            const parts = input.split('/');
-            return parts[parts.length - 1];
-        }
-        return input;
-    };
-
-    return async (args: string[]) => {
-
-        // Validación de argumentos
-        if (args.length === 0) {
-            fail(
-                'No se especificó la URL del cliente',
-                'Uso: clone-client <url-cliente> [url-rama-opcional]'
-            );
-        }
-
-        const clientUrl = args[0];
-        const branchUrlOrName = args[1] || null;
-
-        logger.info('Navegando al directorio de clientes...');
-        shell.cd('~/dev/wolbenvironment/dev/websITS/clients');
-        console.log("Lanzo con url:", clientUrl)
-        const broker = await task('Buscando broker en la base de datos', async () => {
-            const result = await db.searchBrokerOnDB(clientUrl);
-
-            if (!result) {
-                fail(
-                    `No se encontró broker para la URL: ${clientUrl}`,
-                    'Verifica que la URL sea correcta y esté registrada en la BD'
-                );
-            }
-
-            logger.success(`Broker encontrado: ${result}`);
-            return result;
-        });
-
-        const brokerPath = `~/dev/wolbenvironment/dev/websITS/clients/${broker}`;
-        const dirExists = fs.exists(brokerPath);
-
-        if (dirExists) {
-            logger.warn(`El directorio '${broker}' ya existe`);
-
-            const choice = await shell.input(
-                '¿Qué deseas hacer? (s)obrescribir / (m)antener / (r)enombrar: '
-            );
-
-            if (choice.toLowerCase() === 'm' || choice.toLowerCase() === 'mantener') {
-                logger.info('Manteniendo directorio existente. Finalizando...');
-                return;
-            } else if (choice.toLowerCase() === 'r' || choice.toLowerCase() === 'renombrar') {
-                await task('Renombrando directorio existente', async () => {
-                    await shell.exec(`mv ${broker} ${broker}.bak`);
-                    logger.success(`Directorio renombrado a: ${broker}.bak`);
-                });
-            } else if (choice.toLowerCase() === 's' || choice.toLowerCase() === 'sobrescribir') {
-                await task('Eliminando directorio existente', async () => {
-                    await shell.exec(`rm -rf ${broker}`);
-                    logger.success('Directorio eliminado');
-                });
-            } else {
-                fail('Opción no válida', 'Usa: s (sobrescribir), m (mantener) o r (renombrar)');
-            }
-        }
-
-        const repoUrl = `git@github.com:Avantio/${broker}`;
-        logger.info(`Repositorio: ${repoUrl}`);
-
-        const loader = shell.showLoader('Clonando repositorio desde GitHub...');
-
-        await task('Clonando repositorio', async () => {
-            await git.clone(repoUrl);
-            loader.stop();
-            logger.success('Repositorio clonado exitosamente');
-        }, false, () => loader.stop());
-
-        shell.cd(broker);
-
-        let branchName: string;
-
-        if (branchUrlOrName) {
-            branchName = extractBranchName(branchUrlOrName);
-            logger.info(`Rama extraída: ${branchName}`);
-        } else {
-            const answer = await shell.input('🌿 ¿Qué rama quieres usar? (nombre o URL): ');
-            branchName = extractBranchName(answer);
-        }
-
-        await task(`Cambiando a la rama: ${branchName}`, async () => {
-            if (branchName.length > 0) {
-                await shell.exec(`git checkout -b ${branchName}`);
-                logger.success(`Ahora estás en la rama: ${branchName}`);
-            } else {
-                logger.info('No se va a generar ninguna rama nueva')
-            }
-        });
-        logger.success(`Repositorio ${broker} clonado y configurado exitosamente`);
-
-    };
-};
-
-// export const Test = {
-//     args: ['https://www.feelporto.com/'],
-//     mockInputs: {
-//         'sobrescribir': 'm',  
-//         'rama': '' 
-//     }
-// }

package/src/commands/install.tyr.ts

@@ -1,61 +0,0 @@
-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.');
-    };
-};