theus-cli-linux-arm64 0.2.84

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

@@ -0,0 +1,447 @@
+#!/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

@@ -0,0 +1,232 @@
+#!/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

@@ -0,0 +1,27 @@
+#!/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;
+});