@orxataguy/tyr 1.0.8 → 1.0.10-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.8",
+  "version": "1.0.10-beta.0",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"
@@ -22,6 +22,9 @@
     "release:patch": "npm version patch && git push --follow-tags",
     "release:minor": "npm version minor && git push --follow-tags",
     "release:major": "npm version major && git push --follow-tags",
+    "release:beta": "npm version prerelease --preid=beta && git push --follow-tags && npm publish --tag beta",
+    "release:beta:minor": "npm version preminor --preid=beta && git push --follow-tags && npm publish --tag beta",
+    "release:beta:major": "npm version premajor --preid=beta && git push --follow-tags && npm publish --tag beta",
     "config": "node bin/tyr.js install"
   },
   "keywords": [
@@ -49,6 +52,7 @@
     "find-config": "^1.0.0",
     "inquirer": "^13.2.1",
     "js-yaml": "^4.1.1",
+    "mongodb": "^7.2.0",
     "mssql": "^12.2.0",
     "tsx": "^4.21.0"
   },

package/src/core/Container.ts

@@ -5,9 +5,11 @@ import { DockerManager } from '../lib/DockerManager.js';
 import { GitManager } from '../lib/GitManager.js';
 import { SystemManager } from '../lib/SystemManager.js';
 import { SQLManager } from '../lib/SQLManager.js';
+import { MongoManager } from '../lib/MongoManager.js';
 import { WebManager } from '../lib/WebManager.js';
 import { WorkspaceManager } from '../lib/WorkspaceManager.js';
 import { JiraManager } from '../lib/JiraManager.js';
+import { SetupManager } from '../lib/SetupManager.js';
 import { Logger, createLogger } from './Logger.js';
 
 export type { Logger };
@@ -21,9 +23,11 @@ export interface ServiceContainer {
     git: GitManager;
     sys: SystemManager;
     db: SQLManager;
+    mongo: MongoManager;
     web: WebManager;
     workspace: WorkspaceManager;
     jira: JiraManager;
+    setup: SetupManager;
 }
 
 export class Container {
@@ -37,6 +41,7 @@ export class Container {
         const logger = createLogger(isDebug);
         const shell = new ShellManager();
         const db = new SQLManager();
+        const mongo = new MongoManager();
         const web = new WebManager(logger);
         const fs = new FileSystemManager(logger);
 
@@ -44,6 +49,7 @@ export class Container {
             logger,
             shell,
             db,
+            mongo,
             web,
             fs,
             pkg: new PackageManager(shell, logger),
@@ -52,6 +58,7 @@ export class Container {
             sys: new SystemManager(shell, logger),
             workspace: new WorkspaceManager(shell, fs, logger),
             jira: new JiraManager(web, shell, logger),
+            setup: new SetupManager(shell, fs, logger),
         };
     }
 

package/src/lib/MongoManager.ts

@@ -0,0 +1,176 @@
+import { MongoClient, Db, Document, Filter, UpdateFilter, InsertOneResult, InsertManyResult, UpdateResult, DeleteResult, WithId, OptionalUnlessRequiredId, FindOptions } from 'mongodb';
+
+/**
+ * @class MongoManager
+ * @description Conector con MongoDB que gestiona el ciclo de vida de la conexión y expone un CRUD genérico.
+ */
+export class MongoManager {
+  private client!: MongoClient;
+  private db!: Db;
+  private connected = false;
+
+  constructor() {}
+
+  private async init(): Promise<void> {
+    if (!this.connected) {
+      const uri = process.env.MONGO_URI || 'mongodb://localhost:27017';
+      const dbName = process.env.MONGO_DATABASE || '';
+
+      this.client = new MongoClient(uri);
+      await this.client.connect();
+      this.db = this.client.db(dbName);
+      this.connected = true;
+    }
+  }
+
+  private async close(): Promise<void> {
+    if (this.connected && this.client) {
+      await this.client.close();
+      this.connected = false;
+    }
+  }
+
+  /**
+   * @method insertOne
+   * @description Inserta un documento en la colección indicada.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Document} document - Documento a insertar.
+   * @returns {Promise<InsertOneResult>} Resultado de la inserción.
+   * @example
+   * const result = await mongo.insertOne('users', { name: 'Ana', age: 30 });
+   */
+  public async insertOne<T extends Document>(collection: string, document: OptionalUnlessRequiredId<T>): Promise<InsertOneResult<T>> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).insertOne(document);
+    await this.close();
+    return result;
+  }
+
+  /**
+   * @method insertMany
+   * @description Inserta múltiples documentos en la colección indicada.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Document[]} documents - Array de documentos a insertar.
+   * @returns {Promise<InsertManyResult>} Resultado de la inserción.
+   * @example
+   * const result = await mongo.insertMany('users', [{ name: 'Ana' }, { name: 'Luis' }]);
+   */
+  public async insertMany<T extends Document>(collection: string, documents: OptionalUnlessRequiredId<T>[]): Promise<InsertManyResult<T>> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).insertMany(documents);
+    await this.close();
+    return result;
+  }
+
+  /**
+   * @method findOne
+   * @description Busca el primer documento que coincida con el filtro.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Filter<Document>} filter - Filtro de búsqueda.
+   * @param {FindOptions} [options] - Opciones adicionales (proyección, etc.).
+   * @returns {Promise<WithId<T> | null>} El documento encontrado o null.
+   * @example
+   * const user = await mongo.findOne('users', { name: 'Ana' });
+   */
+  public async findOne<T extends Document>(collection: string, filter: Filter<T>, options?: FindOptions): Promise<WithId<T> | null> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).findOne(filter, options);
+    await this.close();
+    return result;
+  }
+
+  /**
+   * @method find
+   * @description Busca todos los documentos que coincidan con el filtro.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Filter<Document>} filter - Filtro de búsqueda. Usa {} para traer todos los documentos.
+   * @param {FindOptions} [options] - Opciones adicionales (proyección, límite, etc.).
+   * @returns {Promise<WithId<T>[]>} Array de documentos encontrados.
+   * @example
+   * const users = await mongo.find('users', { age: { $gte: 18 } });
+   */
+  public async find<T extends Document>(collection: string, filter: Filter<T>, options?: FindOptions): Promise<WithId<T>[]> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).find(filter, options).toArray();
+    await this.close();
+    return result;
+  }
+
+  /**
+   * @method updateOne
+   * @description Actualiza el primer documento que coincida con el filtro.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Filter<Document>} filter - Filtro para identificar el documento.
+   * @param {UpdateFilter<Document>} update - Operación de actualización (ej: { $set: { field: value } }).
+   * @returns {Promise<UpdateResult>} Resultado de la actualización.
+   * @example
+   * const result = await mongo.updateOne('users', { name: 'Ana' }, { $set: { age: 31 } });
+   */
+  public async updateOne<T extends Document>(collection: string, filter: Filter<T>, update: UpdateFilter<T>): Promise<UpdateResult<T>> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).updateOne(filter, update);
+    await this.close();
+    return result;
+  }
+
+  /**
+   * @method updateMany
+   * @description Actualiza todos los documentos que coincidan con el filtro.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Filter<Document>} filter - Filtro para identificar los documentos.
+   * @param {UpdateFilter<Document>} update - Operación de actualización.
+   * @returns {Promise<UpdateResult>} Resultado de la actualización.
+   * @example
+   * const result = await mongo.updateMany('users', { active: false }, { $set: { active: true } });
+   */
+  public async updateMany<T extends Document>(collection: string, filter: Filter<T>, update: UpdateFilter<T>): Promise<UpdateResult<T>> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).updateMany(filter, update);
+    await this.close();
+    return result;
+  }
+
+  /**
+   * @method deleteOne
+   * @description Elimina el primer documento que coincida con el filtro.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Filter<Document>} filter - Filtro para identificar el documento.
+   * @returns {Promise<DeleteResult>} Resultado de la eliminación.
+   * @example
+   * const result = await mongo.deleteOne('users', { name: 'Ana' });
+   */
+  public async deleteOne<T extends Document>(collection: string, filter: Filter<T>): Promise<DeleteResult> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).deleteOne(filter);
+    await this.close();
+    return result;
+  }
+
+  /**
+   * @method deleteMany
+   * @description Elimina todos los documentos que coincidan con el filtro.
+   * @param {string} collection - Nombre de la colección.
+   * @param {Filter<Document>} filter - Filtro para identificar los documentos.
+   * @returns {Promise<DeleteResult>} Resultado de la eliminación.
+   * @example
+   * const result = await mongo.deleteMany('users', { active: false });
+   */
+  public async deleteMany<T extends Document>(collection: string, filter: Filter<T>): Promise<DeleteResult> {
+    await this.init();
+    const result = await this.db.collection<T>(collection).deleteMany(filter);
+    await this.close();
+    return result;
+  }
+}
+
+/**
+ * @object MongoManagerTests
+ * @description Parámetros de pruebas para validar la funcionalidad de MongoManager.
+ */
+export const MongoManagerTests = {
+  // insertOne: { collection: 'test', document: { name: 'test_doc', value: 1 } },
+  // findOne: { collection: 'test', filter: { name: 'test_doc' } },
+  // find: { collection: 'test', filter: {} },
+  // updateOne: { collection: 'test', filter: { name: 'test_doc' }, update: { $set: { value: 2 } } },
+  // deleteOne: { collection: 'test', filter: { name: 'test_doc' } },
+};

package/src/lib/SetupManager.ts

@@ -0,0 +1,328 @@
+import path from 'path';
+import { ShellManager } from './ShellManager.js';
+import { FileSystemManager } from './FileSystemManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class SetupManager
+ * @description Utilities for bootstrapping a development environment from a
+ * remote repository. Covers OS detection, dependency checks, docker-compose
+ * introspection, compose/buildx installation, Makefile generation, and
+ * migration-strategy detection.
+ */
+export class SetupManager {
+    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;
+    }
+
+    // ── OS / package manager ────────────────────────────────────────────────
+
+    /**
+     * @method detectPkgMgr
+     * @description Detects the system package manager including apk (Alpine Linux).
+     * Checks: apk → apt → brew → dnf on Unix; winget → choco → scoop on Windows.
+     * @returns {Promise<string>} Manager name ('apk','apt','brew','dnf','winget',
+     *   'choco','scoop') or 'unknown' if none found.
+     * @example
+     * const mgr = await setup.detectPkgMgr();
+     * logger.info(`Package manager: ${mgr}`);
+     */
+    public async detectPkgMgr(): Promise<string> {
+        const candidates: [string, string][] =
+            process.platform === 'win32'
+                ? [['winget', 'winget'], ['choco', 'choco'], ['scoop', 'scoop']]
+                : [['apk', 'apk'], ['apt-get', 'apt'], ['brew', 'brew'], ['dnf', 'dnf']];
+
+        for (const [bin, name] of candidates) {
+            const found = await this.shell.exec(
+                `which ${bin} 2>/dev/null && echo yes || echo no`
+            ).catch(() => 'no');
+            if (found.trim() === 'yes') return name;
+        }
+        return 'unknown';
+    }
+
+    /**
+     * @method sysInstall
+     * @description Installs a system-level package using the detected package manager.
+     * @param {string} pkgMgr - Package manager name as returned by detectPkgMgr().
+     * @param {string} pkg - Package name to install (e.g. 'git', 'nodejs', 'docker').
+     * @example
+     * await setup.sysInstall('apk', 'git');
+     */
+    public async sysInstall(pkgMgr: string, pkg: string): Promise<void> {
+        const cmds: Record<string, string> = {
+            apk:    `apk add --no-cache ${pkg}`,
+            apt:    `apt-get install -y ${pkg}`,
+            brew:   `brew install ${pkg}`,
+            dnf:    `sudo dnf install -y ${pkg}`,
+            winget: `winget install ${pkg}`,
+            choco:  `choco install -y ${pkg}`,
+            scoop:  `scoop install ${pkg}`,
+        };
+        const cmd = cmds[pkgMgr];
+        if (!cmd) throw new TyrError(`Unsupported package manager: ${pkgMgr}`);
+        try {
+            await this.shell.exec(cmd);
+        } catch (e) {
+            throw new TyrError(`Could not install package '${pkg}' with ${pkgMgr}.`, e, `Run the install command manually: ${cmd}`);
+        }
+    }
+
+    /**
+     * @method binExists
+     * @description Checks whether a binary is available on PATH.
+     * @param {string} bin - Binary name to look for (e.g. 'git', 'docker').
+     * @returns {Promise<boolean>} True if the binary is found.
+     * @example
+     * if (!await setup.binExists('docker')) fail('Docker is required.');
+     */
+    public async binExists(bin: string): Promise<boolean> {
+        const result = await this.shell.exec(
+            `which ${bin} 2>/dev/null && echo yes || echo no`
+        ).catch(() => 'no');
+        return result.trim() === 'yes';
+    }
+
+    // ── docker-compose file introspection ───────────────────────────────────
+
+    /**
+     * @method findComposeFile
+     * @description Locates a docker-compose file in the given directory.
+     * Checks: docker-compose.yml, docker-compose.yaml,
+     *   docker-compose.override.yml, compose.yml, compose.yaml.
+     * @param {string} dir - Directory to search in.
+     * @returns {string|null} Absolute path of the compose file, or null.
+     * @example
+     * const file = setup.findComposeFile('/path/to/repo');
+     * if (!file) logger.warn('No compose file found.');
+     */
+    public findComposeFile(dir: string): string | null {
+        const candidates = [
+            'docker-compose.yml',
+            'docker-compose.yaml',
+            'docker-compose.override.yml',
+            'compose.yml',
+            'compose.yaml',
+        ];
+        for (const f of candidates) {
+            const full = path.join(dir, f);
+            if (this.fs.exists(full)) return full;
+        }
+        return null;
+    }
+
+    /**
+     * @method extractPorts
+     * @description Extracts unique host ports from a docker-compose file.
+     * Handles all four YAML port formats:
+     *   - "HOST:CONTAINER"  (quoted or unquoted)
+     *   - HOST:CONTAINER    (numeric pair)
+     *   - PORT              (single plain number)
+     *   - published: PORT   (long-form mapping)
+     * @param {string} composeFile - Absolute path to the compose file.
+     * @returns {Promise<number[]>} Sorted list of unique host port numbers.
+     * @example
+     * const ports = await setup.extractPorts('/repo/docker-compose.yml');
+     * // [3000, 5432, 8080]
+     */
+    public async extractPorts(composeFile: string): Promise<number[]> {
+        const portSet = new Set<number>();
+
+        const addPorts = (raw: string) => {
+            for (const line of raw.split('\n')) {
+                const n = parseInt(line.trim(), 10);
+                if (!isNaN(n) && n > 0) portSet.add(n);
+            }
+        };
+
+        // Format 1+2: - "HOST:CONTAINER" or - HOST:CONTAINER
+        addPorts(await this.shell.exec(
+            `grep -E '^\\s*-\\s+"?[0-9]+:[0-9]+"?' "${composeFile}" 2>/dev/null | grep -oE '[0-9]+:[0-9]+' | cut -d: -f1 || true`
+        ).catch(() => ''));
+
+        // Format 3: - PORT (single number)
+        addPorts(await this.shell.exec(
+            `grep -E '^\\s*-\\s+"?[0-9]+"?\\s*$' "${composeFile}" 2>/dev/null | grep -oE '[0-9]+' || true`
+        ).catch(() => ''));
+
+        // Format 4: published: PORT
+        addPorts(await this.shell.exec(
+            `grep -E '^\\s+published:\\s*[0-9]+' "${composeFile}" 2>/dev/null | grep -oE '[0-9]+' || true`
+        ).catch(() => ''));
+
+        return Array.from(portSet).sort((a, b) => a - b);
+    }
+
+    /**
+     * @method getAppService
+     * @description Detects the main application service in a docker-compose file.
+     * Tries preferred names first (app, web, backend, api, server, worker),
+     * then falls back to the first service defined.
+     * @param {string} composeFile - Absolute path to the compose file.
+     * @returns {Promise<string>} Service name, or empty string if not found.
+     * @example
+     * const svc = await setup.getAppService('/repo/docker-compose.yml');
+     * // 'api'
+     */
+    public async getAppService(composeFile: string): Promise<string> {
+        const preferred = ['app', 'web', 'backend', 'api', 'server', 'worker'];
+        for (const svc of preferred) {
+            const r = await this.shell.exec(
+                `grep -qE "^  ${svc}:" "${composeFile}" 2>/dev/null && echo yes || echo no`
+            ).catch(() => 'no');
+            if (r.trim() === 'yes') return svc;
+        }
+        const first = await this.shell.exec(
+            `grep -E "^  [a-zA-Z]" "${composeFile}" 2>/dev/null | head -1 | sed 's/://;s/^[[:space:]]*//'`
+        ).catch(() => '');
+        return first.trim();
+    }
+
+    // ── docker compose / buildx installation ────────────────────────────────
+
+    /**
+     * @method getComposeCmd
+     * @description Resolves the available docker compose command.
+     * Prefers the compose plugin ('docker compose'), falls back to the
+     * standalone binary ('docker-compose'), and installs it from GitHub
+     * (or pip as a last resort) if neither is found.
+     * @returns {Promise<string|null>} Command string, or null if unavailable.
+     * @example
+     * const cmd = await setup.getComposeCmd();
+     * if (!cmd) fail('docker compose is required.');
+     */
+    public async getComposeCmd(): Promise<string | null> {
+        const pluginOk = await this.shell.exec('docker compose version 2>/dev/null')
+            .then(() => true).catch(() => false);
+        if (pluginOk) return 'docker compose';
+
+        if (await this.binExists('docker-compose')) return 'docker-compose';
+
+        this.logger.warn('docker-compose no encontrado. Intentando instalar...');
+
+        const rawArch = await this.shell.exec('uname -m').catch(() => 'x86_64');
+        const osName  = await this.shell.exec("uname -s | tr '[:upper:]' '[:lower:]'").catch(() => 'linux');
+        const bin     = '/usr/local/bin/docker-compose';
+        const url     = `https://github.com/docker/compose/releases/latest/download/docker-compose-${osName.trim()}-${rawArch.trim()}`;
+
+        this.logger.info('Descargando docker-compose desde GitHub...');
+        try {
+            await this.shell.exec(`curl -fsSL "${url}" -o "${bin}" && chmod +x "${bin}"`);
+            if (await this.shell.exec('docker-compose version 2>/dev/null').then(() => true).catch(() => false)) {
+                this.logger.success('docker-compose instalado correctamente.');
+                return 'docker-compose';
+            }
+        } catch { /* fall through to pip */ }
+
+        const pip = await this.shell.exec('which pip3 2>/dev/null || which pip 2>/dev/null').catch(() => '');
+        if (pip.trim()) {
+            try {
+                await this.shell.exec(
+                    `${pip.trim()} install --quiet docker-compose --break-system-packages 2>/dev/null || ${pip.trim()} install --quiet docker-compose`
+                );
+                if (await this.binExists('docker-compose')) {
+                    this.logger.success('docker-compose instalado via pip.');
+                    return 'docker-compose';
+                }
+            } catch { /* fall through */ }
+        }
+
+        this.logger.warn('No se pudo instalar docker-compose automaticamente.');
+        this.logger.warn('Instalalo manualmente: https://docs.docker.com/compose/install/');
+        return null;
+    }
+
+    /**
+     * @method ensureBuildx
+     * @description Installs the docker buildx plugin if it is not already available.
+     * Fetches the latest release URL dynamically from the GitHub API.
+     * @example
+     * await setup.ensureBuildx();
+     */
+    public async ensureBuildx(): Promise<void> {
+        const ok = await this.shell.exec('docker buildx version 2>/dev/null')
+            .then(() => true).catch(() => false);
+        if (ok) return;
+
+        this.logger.info('Instalando docker buildx plugin...');
+        const rawArch   = await this.shell.exec('uname -m').catch(() => 'x86_64');
+        const arch      = rawArch.trim().replace('x86_64', 'amd64').replace('aarch64', 'arm64');
+        const osName    = await this.shell.exec("uname -s | tr '[:upper:]' '[:lower:]'").catch(() => 'linux');
+        const pluginDir = '/usr/local/lib/docker/cli-plugins';
+
+        const urlRaw = await this.shell.exec(
+            `wget -qO- https://api.github.com/repos/docker/buildx/releases/latest ` +
+            `| grep "browser_download_url" | grep '"${osName.trim()}-${arch}"' | cut -d'"' -f4 || true`
+        ).catch(() => '');
+
+        if (!urlRaw.trim()) {
+            this.logger.warn('No se pudo obtener la URL de docker buildx. El build puede mostrar advertencias.');
+            return;
+        }
+        try {
+            await this.shell.exec(
+                `mkdir -p "${pluginDir}" && wget -qO "${pluginDir}/docker-buildx" "${urlRaw.trim()}" && chmod +x "${pluginDir}/docker-buildx"`
+            );
+            this.logger.success('docker buildx instalado.');
+        } catch {
+            this.logger.warn('No se pudo instalar docker buildx. El build puede mostrar advertencias.');
+        }
+    }
+
+    // ── Makefile generation ─────────────────────────────────────────────────
+
+    /**
+     * @method generateMakefile
+     * @description Creates a Makefile with docker compose shortcuts in the repo
+     * directory. If a Makefile already exists, writes Makefile.dev instead.
+     * Does nothing if the target file is already present.
+     * @param {string} repoDir - Absolute path to the cloned repository.
+     * @example
+     * await setup.generateMakefile('/workspace/my-repo');
+     */
+    public async generateMakefile(repoDir: string): Promise<void> {
+        const hasExisting  = this.fs.exists(path.join(repoDir, 'Makefile'));
+        const makefileName = hasExisting ? 'Makefile.dev' : 'Makefile';
+        const makefilePath = path.join(repoDir, makefileName);
+        const invokePrefix = hasExisting ? 'make -f Makefile.dev' : 'make';
+
+        if (this.fs.exists(makefilePath)) {
+            this.logger.info(`${makefileName} ya existe. No se sobreescribe.`);
+            return;
+        }
+
+        const TAB = '\t';
+        const content = [
+            `# ${makefileName} generado por setup-dev`,
+            '',
+            'up:',      TAB + 'docker-compose up -d',                '',
+            'build:',   TAB + 'docker-compose up -d --build',        '',
+            'stop:',    TAB + 'docker-compose down --remove-orphans', '',
+            'restart:', TAB + 'docker-compose restart',               '',
+            'logs:',    TAB + 'docker-compose logs -f',               '',
+            'ps:',      TAB + 'docker-compose ps',                    '',
+        ].join('\n');
+
+        await this.fs.write(makefilePath, content);
+        this.logger.success(`${makefileName} generado en: ${makefilePath}`);
+        this.logger.info(`  ${invokePrefix} up      -> arrancar contenedores`);
+        this.logger.info(`  ${invokePrefix} build   -> rebuild y arrancar`);
+        this.logger.info(`  ${invokePrefix} stop    -> parar y eliminar (sin orphans)`);
+        this.logger.info(`  ${invokePrefix} logs    -> ver logs en tiempo real`);
+        this.logger.info(`  ${invokePrefix} ps      -> estado de los contenedores`);
+    }
+}
+
+export const SetupManagerTests = {
+    detectPkgMgr: {},
+    binExists: { bin: 'git' },
+    findComposeFile: { dir: '/tmp' },
+};