theus-cli-linux-x64 1.2.2 → 1.3.0

package/vendor/theus-arsenal/scripts/hooks/pre-bash-commit-quality.js

@@ -1,447 +0,0 @@
-#!/usr/bin/env node
-/**
- * Hook PreToolUse: control de calidad previo al commit
- *
- * Ejecuta verificaciones de calidad antes de los comandos git commit:
- * - Detecta los archivos en staging
- * - Ejecuta el linter sobre los archivos en staging (si está disponible)
- * - Busca problemas comunes (console.log, TODO, etc.)
- * - Valida el formato del mensaje de commit (si se proporciona)
- *
- * Multiplataforma (Windows, macOS, Linux)
- *
- * Códigos de salida:
- *   0 - Éxito (permitir el commit)
- *   2 - Bloquear el commit (se encontraron problemas de calidad)
- */
-
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-const MAX_STDIN = 1024 * 1024; // Límite de 1MB
-
-/**
- * Detecta los archivos en staging para el commit
- * @returns {string[]} Arreglo de rutas de archivos en staging
- */
-function getStagedFiles() {
-  const result = spawnSync('git', ['diff', '--cached', '--name-only', '--diff-filter=ACMR'], {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
-  if (result.status !== 0) {
-    return [];
-  }
-  return result.stdout.trim().split('\n').filter(f => f.length > 0);
-}
-
-function getStagedFileContent(filePath) {
-  const result = spawnSync('git', ['show', `:${filePath}`], {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
-  if (result.status !== 0) {
-    return null;
-  }
-  return result.stdout;
-}
-
-/**
- * Indica si un archivo debe pasar por el control de calidad
- * @param {string} filePath
- * @returns {boolean}
- */
-function shouldCheckFile(filePath) {
-  const checkableExtensions = ['.js', '.jsx', '.ts', '.tsx', '.py', '.go', '.rs'];
-  return checkableExtensions.some(ext => filePath.endsWith(ext));
-}
-
-/**
- * Busca problemas en el contenido del archivo
- * @param {string} filePath
- * @returns {object[]} Arreglo de problemas encontrados
- */
-function findFileIssues(filePath) {
-  const issues = [];
-
-  try {
-    const content = getStagedFileContent(filePath);
-    if (content === null || content === undefined) {
-      return issues;
-    }
-    const lines = content.split('\n');
-
-    lines.forEach((line, index) => {
-      const lineNum = index + 1;
-
-      // Buscar console.log
-      if (line.includes('console.log') && !line.trim().startsWith('//') && !line.trim().startsWith('*')) {
-        issues.push({
-          type: 'console.log',
-          message: `console.log encontrado en la línea ${lineNum}`,
-          line: lineNum,
-          severity: 'warning'
-        });
-      }
-
-      // Buscar sentencias debugger
-      if (/\bdebugger\b/.test(line) && !line.trim().startsWith('//')) {
-        issues.push({
-          type: 'debugger',
-          message: `sentencia debugger en la línea ${lineNum}`,
-          line: lineNum,
-          severity: 'error'
-        });
-      }
-
-      // Buscar TODO/FIXME sin referencia a un issue
-      const todoMatch = line.match(/\/\/\s*(TODO|FIXME):?\s*(.+)/);
-      if (todoMatch && !todoMatch[2].match(/#\d+|issue/i)) {
-        issues.push({
-          type: 'todo',
-          message: `TODO/FIXME sin referencia a issue en la línea ${lineNum}: "${todoMatch[2].trim()}"`,
-          line: lineNum,
-          severity: 'info'
-        });
-      }
-
-      // Buscar secretos escritos en el código (patrones básicos)
-      const secretPatterns = [
-        { pattern: /sk-[a-zA-Z0-9]{20,}/, name: 'clave de API con prefijo sk-' },
-        { pattern: /ghp_[a-zA-Z0-9]{36}/, name: 'PAT de GitHub' },
-        { pattern: /AKIA[A-Z0-9]{16}/, name: 'clave de acceso de AWS' },
-        { pattern: /api[_-]?key\s*[=:]\s*['"][^'"]+['"]/i, name: 'clave de API' }
-      ];
-
-      for (const { pattern, name } of secretPatterns) {
-        if (pattern.test(line)) {
-          issues.push({
-            type: 'secret',
-            message: `Posible ${name} expuesta en la línea ${lineNum}`,
-            line: lineNum,
-            severity: 'error'
-          });
-        }
-      }
-    });
-  } catch {
-    // Archivo no legible, omitir
-  }
-
-  return issues;
-}
-
-/**
- * Valida el formato del mensaje de commit
- * @param {string} command
- * @returns {object|null} Resultado de validación o null si no hay mensaje que validar
- */
-function validateCommitMessage(command) {
-  // Extraer el mensaje de commit del comando
-  const messageMatch = command.match(/(?:-m|--message)[=\s]+["']?([^"']+)["']?/);
-  if (!messageMatch) return null;
-
-  const message = messageMatch[1];
-  const issues = [];
-
-  // Verificar el formato de conventional commit
-  const conventionalCommit = /^(feat|fix|docs|style|refactor|test|chore|build|ci|perf|revert)(\(.+\))?:\s*.+/;
-  if (!conventionalCommit.test(message)) {
-    issues.push({
-      type: 'format',
-      message: 'El mensaje de commit no sigue el formato de conventional commits',
-      suggestion: 'Usa el formato: tipo(alcance): descripción (p. ej. "feat(auth): agregar flujo de login")'
-    });
-  }
-
-  // Verificar la longitud del mensaje
-  if (message.length > 72) {
-    issues.push({
-      type: 'length',
-      message: `Mensaje de commit demasiado largo (${message.length} caracteres, máximo 72)`,
-      suggestion: 'Mantén la primera línea por debajo de 72 caracteres'
-    });
-  }
-
-  // Verificar minúscula inicial (convención)
-  if (conventionalCommit.test(message)) {
-    const afterColon = message.split(':')[1];
-    if (afterColon && /^[A-Z]/.test(afterColon.trim())) {
-      issues.push({
-        type: 'capitalization',
-        message: 'El asunto debe empezar en minúscula después del tipo',
-        suggestion: 'Usa minúscula para la primera letra del asunto'
-      });
-    }
-  }
-
-  // Verificar punto final
-  if (message.endsWith('.')) {
-    issues.push({
-      type: 'punctuation',
-      message: 'El mensaje de commit no debe terminar con punto',
-      suggestion: 'Elimina el punto final'
-    });
-  }
-
-  return { message, issues };
-}
-
-function getPathEnv() {
-  const pathKey = Object.keys(process.env).find(key => key.toLowerCase() === 'path') || 'PATH';
-  return process.env[pathKey] || '';
-}
-
-function isPathLike(command) {
-  return command.includes(path.sep) || (process.platform === 'win32' && /[\\/]/.test(command));
-}
-
-function getExecutableCandidates(command) {
-  if (process.platform !== 'win32' || path.extname(command)) {
-    return [command];
-  }
-
-  const pathExt = process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD';
-  return [command, ...pathExt.split(';').filter(Boolean).map(ext => `${command}${ext.toLowerCase()}`)];
-}
-
-function resolveCommand(command) {
-  if (isPathLike(command)) {
-    return getExecutableCandidates(command).find(candidate => fs.existsSync(candidate)) || null;
-  }
-
-  for (const dir of getPathEnv().split(path.delimiter).filter(Boolean)) {
-    for (const candidate of getExecutableCandidates(path.join(dir, command))) {
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-    }
-  }
-
-  return null;
-}
-
-function runLinterCommand(command, args) {
-  const useShell = process.platform === 'win32' && /\.(?:cmd|bat)$/i.test(command);
-  return spawnSync(command, args, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    timeout: 30000,
-    shell: useShell
-  });
-}
-
-function commandOutput(result) {
-  return result.stdout || result.stderr || result.error?.message || '';
-}
-
-/**
- * Ejecuta el linter sobre los archivos en staging
- * @param {string[]} files
- * @returns {object} Resultados del lint
- */
-function runLinter(files) {
-  const jsFiles = files.filter(f => /\.(js|jsx|ts|tsx)$/.test(f));
-  const pyFiles = files.filter(f => f.endsWith('.py'));
-  const goFiles = files.filter(f => f.endsWith('.go'));
-
-  const results = {
-    eslint: null,
-    pylint: null,
-    golint: null
-  };
-
-  // Ejecutar ESLint si está disponible
-  if (jsFiles.length > 0) {
-    const eslintBin = process.platform === 'win32' ? 'eslint.cmd' : 'eslint';
-    const eslintPath = path.join(process.cwd(), 'node_modules', '.bin', eslintBin);
-    if (fs.existsSync(eslintPath)) {
-      const result = runLinterCommand(eslintPath, ['--format', 'compact', ...jsFiles]);
-      results.eslint = {
-        success: result.status === 0,
-        output: commandOutput(result)
-      };
-    }
-  }
-
-  // Ejecutar Pylint si está disponible
-  if (pyFiles.length > 0) {
-    try {
-      const pylintPath = resolveCommand('pylint');
-      if (!pylintPath) {
-        results.pylint = null;
-      } else {
-        const result = runLinterCommand(pylintPath, ['--output-format=text', ...pyFiles]);
-        results.pylint = {
-          success: result.status === 0,
-          output: commandOutput(result)
-        };
-      }
-    } catch {
-      // Pylint no disponible
-    }
-  }
-
-  // Ejecutar golint si está disponible
-  if (goFiles.length > 0) {
-    try {
-      const golintPath = resolveCommand('golint');
-      if (!golintPath) {
-        results.golint = null;
-      } else {
-        const result = runLinterCommand(golintPath, goFiles);
-        results.golint = {
-          success: !result.stdout || result.stdout.trim() === '',
-          output: commandOutput(result)
-        };
-      }
-    } catch {
-      // golint no disponible
-    }
-  }
-
-  return results;
-}
-
-/**
- * Lógica principal — exportada para invocación directa
- * @param {string} rawInput - Cadena JSON cruda recibida por stdin
- * @returns {{output:string, exitCode:number}} Salida de paso y código de salida
- */
-function evaluate(rawInput) {
-  try {
-    const input = JSON.parse(rawInput);
-    const command = input.tool_input?.command || '';
-
-    // Solo ejecutar para comandos git commit
-    if (!command.includes('git commit')) {
-      return { output: rawInput, exitCode: 0 };
-    }
-
-    // Verificar si es un amend (omitir las verificaciones en amends para no bloquear)
-    if (command.includes('--amend')) {
-      return { output: rawInput, exitCode: 0 };
-    }
-
-    // Obtener los archivos en staging
-    const stagedFiles = getStagedFiles();
-
-    if (stagedFiles.length === 0) {
-      console.error('[Hook] No se encontraron archivos en staging. Usa "git add" para agregarlos primero.');
-      return { output: rawInput, exitCode: 0 };
-    }
-
-    console.error(`[Hook] Verificando ${stagedFiles.length} archivo(s) en staging...`);
-
-    // Revisar cada archivo en staging
-    const filesToCheck = stagedFiles.filter(shouldCheckFile);
-    let totalIssues = 0;
-    let errorCount = 0;
-    let warningCount = 0;
-    let infoCount = 0;
-
-    for (const file of filesToCheck) {
-      const fileIssues = findFileIssues(file);
-      if (fileIssues.length > 0) {
-        console.error(`\n[ARCHIVO] ${file}`);
-        for (const issue of fileIssues) {
-          const label = issue.severity === 'error' ? 'ERROR' : issue.severity === 'warning' ? 'ADVERTENCIA' : 'INFO';
-          console.error(`  ${label} Línea ${issue.line}: ${issue.message}`);
-          totalIssues++;
-          if (issue.severity === 'error') errorCount++;
-          if (issue.severity === 'warning') warningCount++;
-          if (issue.severity === 'info') infoCount++;
-        }
-      }
-    }
-
-    // Validar el mensaje de commit si se proporcionó
-    const messageValidation = validateCommitMessage(command);
-    if (messageValidation && messageValidation.issues.length > 0) {
-      console.error('\nProblemas en el mensaje de commit:');
-      for (const issue of messageValidation.issues) {
-        console.error(`  ADVERTENCIA ${issue.message}`);
-        if (issue.suggestion) {
-          console.error(`     SUGERENCIA ${issue.suggestion}`);
-        }
-        totalIssues++;
-        warningCount++;
-      }
-    }
-
-    // Ejecutar el linter
-    const lintResults = runLinter(filesToCheck);
-
-    if (lintResults.eslint && !lintResults.eslint.success) {
-      console.error('\nProblemas de ESLint:');
-      console.error(lintResults.eslint.output);
-      totalIssues++;
-      errorCount++;
-    }
-
-    if (lintResults.pylint && !lintResults.pylint.success) {
-      console.error('\nProblemas de Pylint:');
-      console.error(lintResults.pylint.output);
-      totalIssues++;
-      errorCount++;
-    }
-
-    if (lintResults.golint && !lintResults.golint.success) {
-      console.error('\nProblemas de golint:');
-      console.error(lintResults.golint.output);
-      totalIssues++;
-      errorCount++;
-    }
-
-    // Resumen
-    if (totalIssues > 0) {
-      console.error(`\nResumen: ${totalIssues} problema(s) encontrado(s) (${errorCount} error(es), ${warningCount} advertencia(s), ${infoCount} info)`);
-
-      if (errorCount > 0) {
-        console.error('\n[Hook] ERROR: Commit bloqueado por problemas críticos. Corrígelos antes de hacer commit.');
-        return { output: rawInput, exitCode: 2 };
-      } else {
-        console.error('\n[Hook] ADVERTENCIA: Se encontraron advertencias. Considera corregirlas, pero el commit está permitido.');
-        console.error('[Hook] Corrige los problemas señalados antes de commitear (el flag --no-verify está bloqueado por política).');
-      }
-    } else {
-      console.error('\n[Hook] OK: Todas las verificaciones pasaron.');
-    }
-
-  } catch (error) {
-    console.error(`[Hook] Error: ${error.message}`);
-    // No bloqueante en caso de error
-  }
-
-  return { output: rawInput, exitCode: 0 };
-}
-
-function run(rawInput) {
-  const result = evaluate(rawInput);
-  return {
-    stdout: result.output,
-    exitCode: result.exitCode,
-  };
-}
-
-// ── Punto de entrada por stdin ────────────────────────────────────
-if (require.main === module) {
-  let data = '';
-  process.stdin.setEncoding('utf8');
-
-  process.stdin.on('data', chunk => {
-    if (data.length < MAX_STDIN) {
-      const remaining = MAX_STDIN - data.length;
-      data += chunk.substring(0, remaining);
-    }
-  });
-
-  process.stdin.on('end', () => {
-    const result = evaluate(data);
-    process.stdout.write(result.output);
-    process.exit(result.exitCode);
-  });
-}
-
-module.exports = { run, evaluate };

package/vendor/theus-arsenal/scripts/hooks/pre-bash-dev-server-block.js

@@ -1,232 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const MAX_STDIN = 1024 * 1024;
-const path = require('path');
-const { splitShellSegments } = require('../lib/shell-split');
-const {
-  extractCommandSubstitutions,
-  extractSubshellGroups
-} = require('../lib/shell-substitution');
-
-const DEV_COMMAND_WORDS = new Set([
-  'npm',
-  'pnpm',
-  'yarn',
-  'bun',
-  'npx',
-  'tmux'
-]);
-const SKIPPABLE_PREFIX_WORDS = new Set(['env', 'command', 'builtin', 'exec', 'noglob', 'sudo', 'nohup']);
-const PREFIX_OPTION_VALUE_WORDS = {
-  env: new Set(['-u', '-C', '-S', '--unset', '--chdir', '--split-string']),
-  sudo: new Set([
-    '-u',
-    '-g',
-    '-h',
-    '-p',
-    '-r',
-    '-t',
-    '-C',
-    '--user',
-    '--group',
-    '--host',
-    '--prompt',
-    '--role',
-    '--type',
-    '--close-from'
-  ])
-};
-
-function readToken(input, startIndex) {
-  let index = startIndex;
-  while (index < input.length && /\s/.test(input[index])) index += 1;
-  if (index >= input.length) return null;
-
-  let token = '';
-  let quote = null;
-
-  while (index < input.length) {
-    const ch = input[index];
-
-    if (quote) {
-      if (ch === quote) {
-        quote = null;
-        index += 1;
-        continue;
-      }
-
-      if (ch === '\\' && quote === '"' && index + 1 < input.length) {
-        token += input[index + 1];
-        index += 2;
-        continue;
-      }
-
-      token += ch;
-      index += 1;
-      continue;
-    }
-
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      index += 1;
-      continue;
-    }
-
-    if (/\s/.test(ch)) break;
-
-    if (ch === '\\' && index + 1 < input.length) {
-      token += input[index + 1];
-      index += 2;
-      continue;
-    }
-
-    token += ch;
-    index += 1;
-  }
-
-  return { token, end: index };
-}
-
-function shouldSkipOptionValue(wrapper, optionToken) {
-  if (!wrapper || !optionToken || optionToken.includes('=')) return false;
-  const optionSet = PREFIX_OPTION_VALUE_WORDS[wrapper];
-  return Boolean(optionSet && optionSet.has(optionToken));
-}
-
-function isOptionToken(token) {
-  return token.startsWith('-') && token.length > 1;
-}
-
-function normalizeCommandWord(token) {
-  if (!token) return '';
-  const base = path.basename(token).toLowerCase();
-  return base.replace(/\.(cmd|exe|bat)$/i, '');
-}
-
-function getLeadingCommandWord(segment) {
-  let index = 0;
-  let activeWrapper = null;
-  let skipNextValue = false;
-
-  while (index < segment.length) {
-    const parsed = readToken(segment, index);
-    if (!parsed) return null;
-    index = parsed.end;
-
-    const token = parsed.token;
-    if (!token) continue;
-
-    if (skipNextValue) {
-      skipNextValue = false;
-      continue;
-    }
-
-    if (token === '--') {
-      activeWrapper = null;
-      continue;
-    }
-
-    if (token === '{' || token === '}') continue;
-
-    if (/^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token)) continue;
-
-    const normalizedToken = normalizeCommandWord(token);
-
-    if (SKIPPABLE_PREFIX_WORDS.has(normalizedToken)) {
-      activeWrapper = normalizedToken;
-      continue;
-    }
-
-    if (activeWrapper && isOptionToken(token)) {
-      if (shouldSkipOptionValue(activeWrapper, token)) {
-        skipNextValue = true;
-      }
-      continue;
-    }
-
-    return normalizedToken;
-  }
-
-  return null;
-}
-
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => {
-  if (raw.length < MAX_STDIN) {
-    const remaining = MAX_STDIN - raw.length;
-    raw += chunk.substring(0, remaining);
-  }
-});
-
-const TMUX_LAUNCHER = /^\s*tmux\s+(new|new-session|new-window|split-window)\b/;
-// Se usa el lookahead final (?![\w-]) en lugar de \b: \b trata el guion como
-// límite de palabra, así que `dev\b` coincide con el prefijo `dev` de scripts
-// distintos como `dev-setup` / `dev-docs` / `dev-build` y los bloquea por error.
-// El lookahead sigue coincidiendo con el servidor de desarrollo (`dev`, `dev;`,
-// `dev:ssr`, ...) pero no con un script `dev-<sufijo>`.
-const DEV_PATTERN = /\b(npm\s+run\s+dev|pnpm(?:\s+run)?\s+dev|yarn(?:\s+run)?\s+dev|bun(?:\s+run)?\s+dev)(?![\w-])/;
-
-/**
- * Recolecta cada segmento de línea de comandos que debemos evaluar. Devuelve
- * primero los segmentos de nivel superior y luego los segmentos extraídos de
- * las sustituciones de comandos `$(...)` / backticks y de los grupos de
- * subshell `(...)`, de forma recursiva.
- *
- * Sin esta expansión, la verificación del comando inicial y del patrón dev de
- * más abajo solo ve el comando más externo, por lo que envolturas como
- * `$(npm run dev)` y `(npm run dev)` (que igualmente lanzan un servidor de
- * desarrollo) se cuelan sin ser detectadas.
- */
-function collectCheckSegments(cmd) {
-  const segments = [...splitShellSegments(cmd)];
-  const queue = [cmd];
-  const seen = new Set();
-
-  while (queue.length) {
-    const current = queue.shift();
-    if (seen.has(current)) continue;
-    seen.add(current);
-
-    for (const body of extractCommandSubstitutions(current)) {
-      for (const seg of splitShellSegments(body)) segments.push(seg);
-      queue.push(body);
-    }
-    for (const body of extractSubshellGroups(current)) {
-      for (const seg of splitShellSegments(body)) segments.push(seg);
-      queue.push(body);
-    }
-  }
-
-  return segments;
-}
-
-function isBlockedDevSegment(segment) {
-  const commandWord = getLeadingCommandWord(segment);
-  if (!commandWord || !DEV_COMMAND_WORDS.has(commandWord)) return false;
-  return DEV_PATTERN.test(segment) && !TMUX_LAUNCHER.test(segment);
-}
-
-process.stdin.on('end', () => {
-  try {
-    const input = JSON.parse(raw);
-    const cmd = String(input.tool_input?.command || '');
-
-    if (process.platform !== 'win32') {
-      const segments = collectCheckSegments(cmd);
-      const hasBlockedDev = segments.some(isBlockedDevSegment);
-
-      if (hasBlockedDev) {
-        console.error('[Hook] BLOQUEADO: el servidor de desarrollo debe ejecutarse en tmux para poder acceder a los logs');
-        console.error('[Hook] Usa: tmux new-session -d -s dev "npm run dev"');
-        console.error('[Hook] Luego: tmux attach -t dev');
-        process.exit(2);
-      }
-    }
-  } catch {
-    // Ignorar errores de parseo y dejar pasar
-  }
-
-  process.stdout.write(raw);
-});

package/vendor/theus-arsenal/scripts/hooks/pre-bash-dispatcher.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// Despachador PreToolUse para comandos Bash: delega la evaluación en el
-// despachador compartido de hooks de Bash.
-
-const { runPreBash } = require('./bash-hook-dispatcher');
-
-let raw = '';
-const MAX_STDIN = 1024 * 1024;
-
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => {
-  if (raw.length < MAX_STDIN) {
-    const remaining = MAX_STDIN - raw.length;
-    raw += chunk.substring(0, remaining);
-  }
-});
-
-process.stdin.on('end', () => {
-  const result = runPreBash(raw);
-  if (result.stderr) {
-    process.stderr.write(result.stderr);
-  }
-  process.stdout.write(result.output);
-  process.exitCode = result.exitCode;
-});