theus-cli 0.2.83 → 0.2.85

package/vendor/theus-arsenal/scripts/lib/project-detect.js

@@ -1,451 +0,0 @@
-/**
- * Detección de tipo de proyecto y framework
- *
- * Detección multiplataforma (Windows, macOS, Linux) del tipo de proyecto
- * inspeccionando los archivos del directorio de trabajo.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Reglas de detección de lenguaje.
- * Cada regla revisa archivos marcadores o patrones glob en la raíz del proyecto.
- */
-const LANGUAGE_RULES = [
-  {
-    type: 'python',
-    markers: ['requirements.txt', 'pyproject.toml', 'setup.py', 'setup.cfg', 'Pipfile', 'poetry.lock'],
-    extensions: ['.py']
-  },
-  {
-    type: 'typescript',
-    markers: ['tsconfig.json', 'tsconfig.build.json'],
-    extensions: ['.ts', '.tsx']
-  },
-  {
-    type: 'javascript',
-    markers: ['package.json', 'jsconfig.json'],
-    extensions: ['.js', '.jsx', '.mjs']
-  },
-  {
-    type: 'golang',
-    markers: ['go.mod', 'go.sum'],
-    extensions: ['.go']
-  },
-  {
-    type: 'rust',
-    markers: ['Cargo.toml', 'Cargo.lock'],
-    extensions: ['.rs']
-  },
-  {
-    type: 'ruby',
-    markers: ['Gemfile', 'Gemfile.lock', 'Rakefile'],
-    extensions: ['.rb']
-  },
-  {
-    type: 'java',
-    markers: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
-    extensions: ['.java']
-  },
-  {
-    type: 'c',
-    markers: [],
-    extensions: ['.c']
-  },
-  {
-    type: 'csharp',
-    markers: [],
-    extensions: ['.cs', '.csproj', '.sln']
-  },
-  {
-    type: 'fsharp',
-    markers: [],
-    extensions: ['.fs', '.fsx', '.fsproj']
-  },
-  {
-    type: 'swift',
-    markers: ['Package.swift'],
-    extensions: ['.swift']
-  },
-  {
-    type: 'kotlin',
-    markers: [],
-    extensions: ['.kt', '.kts']
-  },
-  {
-    type: 'elixir',
-    markers: ['mix.exs'],
-    extensions: ['.ex', '.exs']
-  },
-  {
-    type: 'php',
-    markers: ['composer.json', 'composer.lock'],
-    extensions: ['.php']
-  }
-];
-
-/**
- * Reglas de detección de framework.
- * Se comprueban después de la detección de lenguaje para una identificación más específica.
- */
-const FRAMEWORK_RULES = [
-  // Frameworks de Python
-  { framework: 'django', language: 'python', markers: ['manage.py'], packageKeys: ['django'] },
-  { framework: 'fastapi', language: 'python', markers: [], packageKeys: ['fastapi'] },
-  { framework: 'flask', language: 'python', markers: [], packageKeys: ['flask'] },
-
-  // Frameworks de JavaScript/TypeScript
-  { framework: 'nextjs', language: 'typescript', markers: ['next.config.js', 'next.config.mjs', 'next.config.ts'], packageKeys: ['next'] },
-  { framework: 'react', language: 'typescript', markers: [], packageKeys: ['react'] },
-  { framework: 'vue', language: 'typescript', markers: ['vue.config.js'], packageKeys: ['vue'] },
-  { framework: 'angular', language: 'typescript', markers: ['angular.json'], packageKeys: ['@angular/core'] },
-  { framework: 'svelte', language: 'typescript', markers: ['svelte.config.js'], packageKeys: ['svelte'] },
-  { framework: 'express', language: 'javascript', markers: [], packageKeys: ['express'] },
-  { framework: 'nestjs', language: 'typescript', markers: ['nest-cli.json'], packageKeys: ['@nestjs/core'] },
-  { framework: 'remix', language: 'typescript', markers: [], packageKeys: ['@remix-run/node', '@remix-run/react'] },
-  { framework: 'astro', language: 'typescript', markers: ['astro.config.mjs', 'astro.config.ts'], packageKeys: ['astro'] },
-  { framework: 'nuxt', language: 'typescript', markers: ['nuxt.config.js', 'nuxt.config.ts'], packageKeys: ['nuxt'] },
-  { framework: 'electron', language: 'typescript', markers: [], packageKeys: ['electron'] },
-
-  // Frameworks de Ruby
-  { framework: 'rails', language: 'ruby', markers: ['config/routes.rb', 'bin/rails'], packageKeys: [] },
-
-  // Frameworks de Go
-  { framework: 'gin', language: 'golang', markers: [], packageKeys: ['github.com/gin-gonic/gin'] },
-  { framework: 'echo', language: 'golang', markers: [], packageKeys: ['github.com/labstack/echo'] },
-
-  // Frameworks de Rust
-  { framework: 'actix', language: 'rust', markers: [], packageKeys: ['actix-web'] },
-  { framework: 'axum', language: 'rust', markers: [], packageKeys: ['axum'] },
-
-  // Frameworks de Java
-  { framework: 'spring', language: 'java', markers: [], packageKeys: ['spring-boot', 'org.springframework'] },
-
-  // Frameworks de PHP
-  { framework: 'laravel', language: 'php', markers: ['artisan'], packageKeys: ['laravel/framework'] },
-  { framework: 'symfony', language: 'php', markers: ['symfony.lock'], packageKeys: ['symfony/framework-bundle'] },
-
-  // Frameworks de Elixir
-  { framework: 'phoenix', language: 'elixir', markers: [], packageKeys: ['phoenix'] }
-];
-
-/**
- * Comprueba si existe un archivo relativo al directorio del proyecto
- * @param {string} projectDir - Directorio raíz del proyecto
- * @param {string} filePath - Ruta relativa del archivo
- * @returns {boolean}
- */
-function fileExists(projectDir, filePath) {
-  try {
-    return fs.existsSync(path.join(projectDir, filePath));
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Comprueba si existe algún archivo con la extensión indicada en la raíz del
- * proyecto (no recursivo, solo el primer nivel)
- * @param {string} projectDir - Directorio raíz del proyecto
- * @param {string[]} extensions - Extensiones de archivo a comprobar
- * @returns {boolean}
- */
-function hasFileWithExtension(projectDir, extensions) {
-  try {
-    const entries = fs.readdirSync(projectDir, { withFileTypes: true });
-    return entries.some(entry => {
-      if (!entry.isFile()) return false;
-      const ext = path.extname(entry.name);
-      return extensions.includes(ext);
-    });
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Lee y parsea las dependencias de package.json
- * @param {string} projectDir - Directorio raíz del proyecto
- * @returns {string[]} Arreglo de nombres de dependencias
- */
-function getPackageJsonDeps(projectDir) {
-  try {
-    const pkgPath = path.join(projectDir, 'package.json');
-    if (!fs.existsSync(pkgPath)) return [];
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    return [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})];
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Lee requirements.txt o pyproject.toml para obtener nombres de paquetes de Python
- * @param {string} projectDir - Directorio raíz del proyecto
- * @returns {string[]} Arreglo de nombres de dependencias (en minúsculas)
- */
-function getPythonDeps(projectDir) {
-  const deps = [];
-
-  // requirements.txt
-  try {
-    const reqPath = path.join(projectDir, 'requirements.txt');
-    if (fs.existsSync(reqPath)) {
-      const content = fs.readFileSync(reqPath, 'utf8');
-      content.split('\n').forEach(line => {
-        const trimmed = line.trim();
-        if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('-')) {
-          const name = trimmed
-            .split(/[>=<![;]/)[0]
-            .trim()
-            .toLowerCase();
-          if (name) deps.push(name);
-        }
-      });
-    }
-  } catch {
-    /* ignorar */
-  }
-
-  // pyproject.toml — extracción simple de nombres de dependencias
-  try {
-    const tomlPath = path.join(projectDir, 'pyproject.toml');
-    if (fs.existsSync(tomlPath)) {
-      const content = fs.readFileSync(tomlPath, 'utf8');
-      const depMatches = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
-      if (depMatches) {
-        const block = depMatches[1];
-        block.match(/"([^"]+)"/g)?.forEach(m => {
-          const name = m
-            .replace(/"/g, '')
-            .split(/[>=<![;]/)[0]
-            .trim()
-            .toLowerCase();
-          if (name) deps.push(name);
-        });
-      }
-    }
-  } catch {
-    /* ignorar */
-  }
-
-  return deps;
-}
-
-/**
- * Lee go.mod para obtener las dependencias de módulos de Go
- * @param {string} projectDir - Directorio raíz del proyecto
- * @returns {string[]} Arreglo de rutas de módulos
- */
-function getGoDeps(projectDir) {
-  try {
-    const modPath = path.join(projectDir, 'go.mod');
-    if (!fs.existsSync(modPath)) return [];
-    const content = fs.readFileSync(modPath, 'utf8');
-    const deps = [];
-    const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);
-    if (requireBlock) {
-      requireBlock[1].split('\n').forEach(line => {
-        const trimmed = line.trim();
-        if (trimmed && !trimmed.startsWith('//')) {
-          const parts = trimmed.split(/\s+/);
-          if (parts[0]) deps.push(parts[0]);
-        }
-      });
-    }
-    return deps;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Lee Cargo.toml para obtener las dependencias de crates de Rust
- * @param {string} projectDir - Directorio raíz del proyecto
- * @returns {string[]} Arreglo de nombres de crates
- */
-function getRustDeps(projectDir) {
-  try {
-    const cargoPath = path.join(projectDir, 'Cargo.toml');
-    if (!fs.existsSync(cargoPath)) return [];
-    const content = fs.readFileSync(cargoPath, 'utf8');
-    const deps = [];
-    // Coincide con las secciones [dependencies] y [dev-dependencies]
-    const sections = content.match(/\[(dev-)?dependencies\]([\s\S]*?)(?=\n\[|$)/g);
-    if (sections) {
-      sections.forEach(section => {
-        section.split('\n').forEach(line => {
-          const match = line.match(/^([a-zA-Z0-9_-]+)\s*=/);
-          if (match && !line.startsWith('[')) {
-            deps.push(match[1]);
-          }
-        });
-      });
-    }
-    return deps;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Lee composer.json para obtener las dependencias de paquetes de PHP
- * @param {string} projectDir - Directorio raíz del proyecto
- * @returns {string[]} Arreglo de nombres de paquetes
- */
-function getComposerDeps(projectDir) {
-  try {
-    const composerPath = path.join(projectDir, 'composer.json');
-    if (!fs.existsSync(composerPath)) return [];
-    const composer = JSON.parse(fs.readFileSync(composerPath, 'utf8'));
-    return [...Object.keys(composer.require || {}), ...Object.keys(composer['require-dev'] || {})];
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Lee mix.exs para obtener las dependencias de Elixir (coincidencia simple de patrones)
- * @param {string} projectDir - Directorio raíz del proyecto
- * @returns {string[]} Arreglo de nombres de átomos de dependencias
- */
-function getElixirDeps(projectDir) {
-  try {
-    const mixPath = path.join(projectDir, 'mix.exs');
-    if (!fs.existsSync(mixPath)) return [];
-    const content = fs.readFileSync(mixPath, 'utf8');
-    const deps = [];
-    const matches = content.match(/\{:(\w+)/g);
-    if (matches) {
-      matches.forEach(m => deps.push(m.replace('{:', '')));
-    }
-    return deps;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Detecta los lenguajes y frameworks del proyecto
- * @param {string} [projectDir] - Directorio del proyecto (por defecto: cwd)
- * @returns {{ languages: string[], frameworks: string[], primary: string, projectDir: string }}
- */
-function detectProjectType(projectDir) {
-  projectDir = projectDir || process.cwd();
-  const languages = [];
-  const frameworks = [];
-
-  // Paso 1: detectar lenguajes
-  for (const rule of LANGUAGE_RULES) {
-    const hasMarker = rule.markers.some(m => fileExists(projectDir, m));
-    const hasExt = rule.extensions.length > 0 && hasFileWithExtension(projectDir, rule.extensions);
-
-    if (hasMarker || hasExt) {
-      languages.push(rule.type);
-    }
-  }
-
-  // Deduplicación: si se detectan typescript y javascript a la vez, conservar typescript
-  if (languages.includes('typescript') && languages.includes('javascript')) {
-    const idx = languages.indexOf('javascript');
-    if (idx !== -1) languages.splice(idx, 1);
-  }
-
-  // Paso 2: detectar frameworks según marcadores y dependencias
-  const npmDeps = getPackageJsonDeps(projectDir);
-  const pyDeps = getPythonDeps(projectDir);
-  const goDeps = getGoDeps(projectDir);
-  const rustDeps = getRustDeps(projectDir);
-  const composerDeps = getComposerDeps(projectDir);
-  const elixirDeps = getElixirDeps(projectDir);
-
-  for (const rule of FRAMEWORK_RULES) {
-    // Revisa los archivos marcadores
-    const hasMarker = rule.markers.some(m => fileExists(projectDir, m));
-
-    // Revisa las dependencias de paquetes
-    let hasDep = false;
-    if (rule.packageKeys.length > 0) {
-      let depList = [];
-      switch (rule.language) {
-        case 'python':
-          depList = pyDeps;
-          break;
-        case 'typescript':
-        case 'javascript':
-          depList = npmDeps;
-          break;
-        case 'golang':
-          depList = goDeps;
-          break;
-        case 'rust':
-          depList = rustDeps;
-          break;
-        case 'php':
-          depList = composerDeps;
-          break;
-        case 'elixir':
-          depList = elixirDeps;
-          break;
-      }
-      // Coincidencia con límites: una dependencia coincide con una packageKey
-      // solo cuando es igual a la clave, o cuando la clave es un prefijo seguido
-      // inmediatamente por un delimitador (/ . _ -). La coincidencia por
-      // subcadena simple clasificaba mal `preact` / `reactive` como `react`.
-      // Esto sigue cubriendo los casos reales: react-dom, @remix-run/node,
-      // spring-boot-starter, org.springframework.boot,
-      // github.com/labstack/echo/v4, phoenix_live_view.
-      hasDep = rule.packageKeys.some(key => {
-        const k = key.toLowerCase();
-        return depList.some(dep => {
-          const d = dep.toLowerCase();
-          if (!d.startsWith(k)) return false;
-          return d.length === k.length || /[/._-]/.test(d[k.length]);
-        });
-      });
-    }
-
-    if (hasMarker || hasDep) {
-      frameworks.push(rule.framework);
-    }
-  }
-
-  // Paso 3: determinar el tipo primario
-  let primary = 'unknown';
-  if (frameworks.length > 0) {
-    primary = frameworks[0];
-  } else if (languages.length > 0) {
-    primary = languages[0];
-  }
-
-  // Determina si es fullstack (lenguajes de frontend y backend a la vez)
-  const frontendSignals = ['react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'astro', 'remix'];
-  const backendSignals = ['django', 'fastapi', 'flask', 'express', 'nestjs', 'rails', 'spring', 'laravel', 'phoenix', 'gin', 'echo', 'actix', 'axum'];
-  const hasFrontend = frameworks.some(f => frontendSignals.includes(f));
-  const hasBackend = frameworks.some(f => backendSignals.includes(f));
-
-  if (hasFrontend && hasBackend) {
-    primary = 'fullstack';
-  }
-
-  return {
-    languages,
-    frameworks,
-    primary,
-    projectDir
-  };
-}
-
-module.exports = {
-  detectProjectType,
-  LANGUAGE_RULES,
-  FRAMEWORK_RULES,
-  // Exportados para testing
-  getPackageJsonDeps,
-  getPythonDeps,
-  getGoDeps,
-  getRustDeps,
-  getComposerDeps,
-  getElixirDeps
-};

package/vendor/theus-arsenal/scripts/lib/resolve-formatter.js

@@ -1,193 +0,0 @@
-/**
- * Utilidades compartidas de resolución de formateadores, con caché.
- *
- * Extrae el descubrimiento de la raíz del proyecto, la detección del
- * formateador y la resolución del binario en un solo módulo para que
- * post-edit-format.js y quality-gate.js no dupliquen trabajo ni lecturas
- * del sistema de archivos.
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-// ── Cachés (por proceso; se limpian en la siguiente invocación del hook) ──
-const projectRootCache = new Map();
-const formatterCache = new Map();
-const binCache = new Map();
-
-// ── Listas de archivos de configuración (fuente única de verdad) ─────────
-
-const BIOME_CONFIGS = ['biome.json', 'biome.jsonc'];
-
-const PRETTIER_CONFIGS = [
-  '.prettierrc',
-  '.prettierrc.json',
-  '.prettierrc.js',
-  '.prettierrc.cjs',
-  '.prettierrc.mjs',
-  '.prettierrc.yml',
-  '.prettierrc.yaml',
-  '.prettierrc.toml',
-  'prettier.config.js',
-  'prettier.config.cjs',
-  'prettier.config.mjs'
-];
-
-const PROJECT_ROOT_MARKERS = ['package.json', ...BIOME_CONFIGS, ...PRETTIER_CONFIGS];
-
-// ── Mapeo de shims .cmd en Windows ────────────────────────────────────────
-const WIN_CMD_SHIMS = { npx: 'npx.cmd', pnpm: 'pnpm.cmd', yarn: 'yarn.cmd', bunx: 'bunx.cmd' };
-
-// ── Mapeo formateador → nombre de paquete ─────────────────────────────────
-const FORMATTER_PACKAGES = {
-  biome: { binName: 'biome', pkgName: '@biomejs/biome' },
-  prettier: { binName: 'prettier', pkgName: 'prettier' }
-};
-
-// ── Helpers públicos ──────────────────────────────────────────────────────
-
-/**
- * Sube desde `startDir` hasta encontrar un directorio que contenga un
- * marcador conocido de raíz de proyecto (package.json o configuración de
- * formateador). Devuelve `startDir` como respaldo cuando no hay marcador
- * por encima.
- *
- * @param {string} startDir - Ruta absoluta del directorio de partida
- * @returns {string} Ruta absoluta de la raíz del proyecto
- */
-function findProjectRoot(startDir) {
-  if (projectRootCache.has(startDir)) return projectRootCache.get(startDir);
-
-  const homeDir = os.homedir();
-  let dir = startDir;
-  while (dir !== path.dirname(dir)) {
-    // Se detiene antes de revisar el directorio home para no tratar dotfiles
-    // globales (p. ej. ~/.prettierrc) como marcadores de raíz de proyecto.
-    if (dir === homeDir) break;
-    for (const marker of PROJECT_ROOT_MARKERS) {
-      if (fs.existsSync(path.join(dir, marker))) {
-        projectRootCache.set(startDir, dir);
-        return dir;
-      }
-    }
-    dir = path.dirname(dir);
-  }
-
-  projectRootCache.set(startDir, startDir);
-  return startDir;
-}
-
-/**
- * Detecta el formateador configurado en el proyecto.
- * Biome tiene prioridad sobre Prettier.
- *
- * @param {string} projectRoot - Ruta absoluta de la raíz del proyecto
- * @returns {'biome' | 'prettier' | null}
- */
-function detectFormatter(projectRoot) {
-  if (formatterCache.has(projectRoot)) return formatterCache.get(projectRoot);
-
-  for (const cfg of BIOME_CONFIGS) {
-    if (fs.existsSync(path.join(projectRoot, cfg))) {
-      formatterCache.set(projectRoot, 'biome');
-      return 'biome';
-    }
-  }
-
-  // Revisa la clave "prettier" de package.json antes que los archivos de configuración
-  try {
-    const pkgPath = path.join(projectRoot, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if ('prettier' in pkg) {
-        formatterCache.set(projectRoot, 'prettier');
-        return 'prettier';
-      }
-    }
-  } catch {
-    // package.json malformado — continúa con la detección por archivos
-  }
-
-  for (const cfg of PRETTIER_CONFIGS) {
-    if (fs.existsSync(path.join(projectRoot, cfg))) {
-      formatterCache.set(projectRoot, 'prettier');
-      return 'prettier';
-    }
-  }
-
-  formatterCache.set(projectRoot, null);
-  return null;
-}
-
-/**
- * Resuelve el binario ejecutor y sus argumentos de prefijo para el gestor de
- * paquetes configurado (respeta la variable THEUS_PACKAGE_MANAGER y la
- * configuración del proyecto).
- *
- * @param {string} projectRoot - Ruta absoluta de la raíz del proyecto
- * @returns {{ bin: string, prefix: string[] }}
- */
-function getRunnerFromPackageManager(projectRoot) {
-  const isWin = process.platform === 'win32';
-  const { getPackageManager } = require('./package-manager');
-  const pm = getPackageManager({ projectDir: projectRoot });
-  const execCmd = pm?.config?.execCmd || 'npx';
-  const [rawBin = 'npx', ...prefix] = execCmd.split(/\s+/).filter(Boolean);
-  const bin = isWin ? WIN_CMD_SHIMS[rawBin] || rawBin : rawBin;
-  return { bin, prefix };
-}
-
-/**
- * Resuelve el binario del formateador, prefiriendo la instalación local en
- * node_modules/.bin sobre el comando exec del gestor de paquetes para evitar
- * el costo de resolución de paquetes.
- *
- * @param {string} projectRoot - Ruta absoluta de la raíz del proyecto
- * @param {'biome' | 'prettier'} formatter - Nombre del formateador detectado
- * @returns {{ bin: string, prefix: string[] } | null}
- *   `bin`    – ruta del ejecutable (ruta local absoluta o binario ejecutor)
- *   `prefix` – argumentos extra a anteponer (p. ej. ['@biomejs/biome'] con npx)
- */
-function resolveFormatterBin(projectRoot, formatter) {
-  const cacheKey = `${projectRoot}:${formatter}`;
-  if (binCache.has(cacheKey)) return binCache.get(cacheKey);
-
-  const pkg = FORMATTER_PACKAGES[formatter];
-  if (!pkg) {
-    binCache.set(cacheKey, null);
-    return null;
-  }
-
-  const isWin = process.platform === 'win32';
-  const localBin = path.join(projectRoot, 'node_modules', '.bin', isWin ? `${pkg.binName}.cmd` : pkg.binName);
-
-  if (fs.existsSync(localBin)) {
-    const result = { bin: localBin, prefix: [] };
-    binCache.set(cacheKey, result);
-    return result;
-  }
-
-  const runner = getRunnerFromPackageManager(projectRoot);
-  const result = { bin: runner.bin, prefix: [...runner.prefix, pkg.pkgName] };
-  binCache.set(cacheKey, result);
-  return result;
-}
-
-/**
- * Limpia todas las cachés. Útil para testing.
- */
-function clearCaches() {
-  projectRootCache.clear();
-  formatterCache.clear();
-  binCache.clear();
-}
-
-module.exports = {
-  findProjectRoot,
-  detectFormatter,
-  resolveFormatterBin,
-  clearCaches
-};