theus-cli-linux-x64 1.2.2 → 1.3.0

package/vendor/theus-arsenal/scripts/hooks/block-no-verify.js

@@ -1,556 +0,0 @@
-#!/usr/bin/env node
-/**
- * Hook PreToolUse: bloquear el flag --no-verify
- *
- * Bloquea los flags de git que evitan la ejecucion de hooks (--no-verify,
- * -c core.hooksPath=) para proteger los hooks pre-commit, commit-msg y
- * pre-push de ser omitidos por agentes de IA.
- *
- * Reemplaza una invocacion previa basada en npx que fallaba en proyectos
- * solo-pnpm (EBADDEVENGINES) y que no podia deshabilitarse via
- * THEUS_DISABLED_HOOKS.
- *
- * Codigos de salida:
- *   0 = permitir (no es un comando git o no hay flags de bypass)
- *   2 = bloquear (se detecto un flag de bypass)
- */
-
-'use strict';
-
-const MAX_STDIN = 1024 * 1024;
-let raw = '';
-
-/**
- * Comandos de git que aceptan el flag --no-verify.
- */
-const GIT_COMMANDS_WITH_NO_VERIFY = [
-  'commit',
-  'push',
-  'merge',
-  'cherry-pick',
-  'rebase',
-  'am',
-];
-
-/**
- * Caracteres que pueden aparecer inmediatamente antes de 'git' en una cadena de comando.
- */
-const VALID_BEFORE_GIT = ' \t\n\r;&|$`(<{!"\']/.~\\';
-
-// Los nombres de seccion y de variable en la configuracion de git no
-// distinguen mayusculas de minusculas (los nombres de subseccion si, pero
-// core.hooksPath no tiene subseccion), asi que normalizamos el token
-// candidato a minusculas antes de comparar.
-// Ver https://git-scm.com/docs/git-config — "The variable names are
-// case-insensitive."
-const GIT_CONFIG_KEY_PREFIX = 'core.hookspath=';
-
-const COMMIT_OPTIONS_WITH_VALUE = new Set([
-  '-m',
-  '--message',
-  '-F',
-  '--file',
-  '-C',
-  '--reuse-message',
-  '-c',
-  '--reedit-message',
-  '--author',
-  '--date',
-  '--template',
-  '--fixup',
-  '--squash',
-  '--pathspec-from-file',
-]);
-
-const COMMIT_OPTIONS_WITH_INLINE_VALUE = [
-  '--message=',
-  '--file=',
-  '--reuse-message=',
-  '--reedit-message=',
-  '--author=',
-  '--date=',
-  '--template=',
-  '--fixup=',
-  '--squash=',
-  '--pathspec-from-file=',
-];
-
-// Opciones cortas que reciben un valor. Cuando aparecen dentro de un token
-// de opciones cortas combinadas (p. ej. -tn), el parser de git trata el
-// resto del token como el valor de la opcion (aqui la ruta de plantilla
-// 'n'), asi que el escaner debe detenerse en ese caracter: todo lo que
-// sigue es el valor en linea, no otro flag.
-const COMMIT_SHORT_OPTIONS_WITH_VALUE = new Set(['m', 'F', 'C', 'c', 't']);
-
-function tokenizeShellWords(input, start = 0, end = input.length) {
-  const tokens = [];
-  let value = '';
-  let tokenStart = null;
-  let quote = null;
-  let escaped = false;
-
-  function beginToken(index) {
-    if (tokenStart === null) {
-      tokenStart = index;
-    }
-  }
-
-  function pushToken(index) {
-    if (tokenStart === null) {
-      return;
-    }
-
-    tokens.push({
-      value,
-      start: tokenStart,
-      end: index,
-    });
-    value = '';
-    tokenStart = null;
-  }
-
-  for (let i = start; i < end; i++) {
-    const char = input.charAt(i);
-
-    if (escaped) {
-      beginToken(i - 1);
-      value += char;
-      escaped = false;
-      continue;
-    }
-
-    if (quote) {
-      if (char === quote) {
-        quote = null;
-        continue;
-      }
-
-      if (quote === '"' && char === '\\') {
-        beginToken(i);
-        escaped = true;
-        continue;
-      }
-
-      beginToken(i);
-      value += char;
-      continue;
-    }
-
-    if (char === '"' || char === "'") {
-      beginToken(i);
-      quote = char;
-      continue;
-    }
-
-    if (char === '\\') {
-      beginToken(i);
-      escaped = true;
-      continue;
-    }
-
-    if (/\s/.test(char)) {
-      pushToken(i);
-      continue;
-    }
-
-    beginToken(i);
-    value += char;
-  }
-
-  if (escaped) {
-    value += '\\';
-  }
-  pushToken(end);
-
-  return tokens;
-}
-
-function findCommandSegmentEnd(input, start) {
-  let quote = null;
-  let escaped = false;
-
-  for (let i = start; i < input.length; i++) {
-    const char = input.charAt(i);
-
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-
-    if (quote) {
-      if (quote === '"' && char === '\\') {
-        escaped = true;
-        continue;
-      }
-      if (char === quote) {
-        quote = null;
-      }
-      continue;
-    }
-
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-
-    if (char === '\\') {
-      escaped = true;
-      continue;
-    }
-
-    if (char === ';' || char === '|' || char === '&' || char === '\n') {
-      return i;
-    }
-  }
-
-  return input.length;
-}
-
-function commitOptionConsumesNextValue(value) {
-  if (isCommitNoVerifyShortFlag(value)) {
-    return false;
-  }
-
-  if (COMMIT_OPTIONS_WITH_VALUE.has(value)) {
-    return true;
-  }
-
-  const shortValueOption = getCommitShortValueOption(value);
-  return Boolean(shortValueOption && shortValueOption.consumesNextValue);
-}
-
-function commitOptionContainsInlineValue(value) {
-  if (isCommitNoVerifyShortFlag(value)) {
-    return false;
-  }
-
-  if (COMMIT_OPTIONS_WITH_INLINE_VALUE.some(prefix => value.startsWith(prefix))) {
-    return true;
-  }
-
-  const shortValueOption = getCommitShortValueOption(value);
-  return Boolean(shortValueOption && shortValueOption.containsInlineValue);
-}
-
-function getCommitShortValueOption(value) {
-  if (!value.startsWith('-') || value.startsWith('--') || value === '-') {
-    return null;
-  }
-
-  const options = value.slice(1);
-  for (let i = 0; i < options.length; i++) {
-    if (COMMIT_SHORT_OPTIONS_WITH_VALUE.has(options.charAt(i))) {
-      return {
-        consumesNextValue: i === options.length - 1,
-        containsInlineValue: i < options.length - 1,
-      };
-    }
-  }
-
-  return null;
-}
-
-function isCommitNoVerifyShortFlag(value) {
-  return value === '-n' || /^-n[a-zA-Z]/.test(value);
-}
-
-/**
- * Comprueba si una posicion de la entrada esta dentro de un comentario de shell.
- */
-function isInComment(input, idx) {
-  const lineStart = input.lastIndexOf('\n', idx - 1) + 1;
-  const before = input.slice(lineStart, idx);
-  for (let i = 0; i < before.length; i++) {
-    if (before.charAt(i) === '#') {
-      const prev = i > 0 ? before.charAt(i - 1) : '';
-      if (prev !== '$' && prev !== '\\') return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Busca el siguiente token 'git' en la entrada a partir de una posicion.
- */
-function findGit(input, start) {
-  let pos = start;
-  while (pos < input.length) {
-    const idx = input.indexOf('git', pos);
-    if (idx === -1) return null;
-
-    const isExe = input.slice(idx + 3, idx + 7).toLowerCase() === '.exe';
-    const len = isExe ? 7 : 3;
-    const after = input[idx + len] || ' ';
-    if (!/[\s"']/.test(after)) {
-      pos = idx + 1;
-      continue;
-    }
-
-    const before = idx > 0 ? input[idx - 1] : ' ';
-    if (VALID_BEFORE_GIT.includes(before)) return { idx, len };
-    pos = idx + 1;
-  }
-  return null;
-}
-
-/**
- * Detecta que subcomando de git (commit, push, etc.) se esta invocando.
- * Devuelve { command, offset } donde offset es la posicion justo despues de
- * la palabra clave del subcomando, para que quien llame pueda acotar la
- * comprobacion de flags solo a esa porcion.
- */
-function detectGitCommand(input, start = 0) {
-  while (start < input.length) {
-    const git = findGit(input, start);
-    if (!git) return null;
-
-    if (isInComment(input, git.idx)) {
-      start = git.idx + git.len;
-      continue;
-    }
-
-    // Busca el primer token de subcomando coincidente despues de "git".
-    // Elegimos el mas cercano a "git" para que valores de argumentos como
-    // "git push origin commit" no clasifiquen erroneamente "commit" como el
-    // subcomando.
-    let bestCmd = null;
-    let bestIdx = Infinity;
-
-    for (const cmd of GIT_COMMANDS_WITH_NO_VERIFY) {
-      let searchPos = git.idx + git.len;
-      while (searchPos < input.length) {
-        const cmdIdx = input.indexOf(cmd, searchPos);
-        if (cmdIdx === -1) break;
-
-        const before = cmdIdx > 0 ? input[cmdIdx - 1] : ' ';
-        const after = input[cmdIdx + cmd.length] || ' ';
-        if (!/\s/.test(before)) { searchPos = cmdIdx + 1; continue; }
-        if (!/[\s;&#|>)\]}"']/.test(after) && after !== '') { searchPos = cmdIdx + 1; continue; }
-        if (/[;|]/.test(input.slice(git.idx + git.len, cmdIdx))) break;
-        if (isInComment(input, cmdIdx)) { searchPos = cmdIdx + 1; continue; }
-
-        // Verifica que este token sea la primera palabra que no es flag
-        // despues de "git" — es decir, el subcomando real, y no el valor de
-        // un argumento de otro subcomando.
-        const gap = input.slice(git.idx + git.len, cmdIdx);
-        const tokens = gap.trim().split(/\s+/).filter(Boolean);
-        // Todo token anterior al candidato debe ser un flag o el argumento
-        // de un flag. Los flags globales de git como -c reciben un valor
-        // (p. ej. -c clave=valor).
-        let onlyFlagsAndArgs = true;
-        let expectFlagArg = false;
-        for (const t of tokens) {
-          if (expectFlagArg) { expectFlagArg = false; continue; }
-          if (t.startsWith('-')) {
-            // -c es un flag global de git que toma el siguiente token como argumento
-            if (t === '-c' || t === '-C' || t === '--work-tree' || t === '--git-dir' ||
-                t === '--namespace' || t === '--super-prefix') {
-              expectFlagArg = true;
-            }
-            continue;
-          }
-          onlyFlagsAndArgs = false;
-          break;
-        }
-        if (!onlyFlagsAndArgs) { searchPos = cmdIdx + 1; continue; }
-
-        if (cmdIdx < bestIdx) {
-          bestIdx = cmdIdx;
-          bestCmd = cmd;
-        }
-        break;
-      }
-    }
-
-    if (bestCmd) {
-      return {
-        command: bestCmd,
-        offset: bestIdx + bestCmd.length,
-        gitStart: git.idx,
-        gitEnd: git.idx + git.len,
-        commandStart: bestIdx,
-      };
-    }
-
-    start = git.idx + git.len;
-  }
-  return null;
-}
-
-/**
- * Comprueba si la entrada contiene un flag --no-verify para un comando git
- * concreto. Solo inspecciona la porcion de la entrada que empieza en `offset`
- * (la posicion justo despues de la palabra clave del subcomando detectado)
- * para no emparejar por error flags que pertenecen a comandos anteriores de
- * una cadena.
- */
-function hasNoVerifyFlag(input, command, offset) {
-  const segmentEnd = findCommandSegmentEnd(input, offset);
-  const tokens = tokenizeShellWords(input, offset, segmentEnd);
-  let skipNext = false;
-
-  for (const token of tokens) {
-    const value = token.value;
-
-    if (skipNext) {
-      skipNext = false;
-      continue;
-    }
-
-    if (value === '--') {
-      break;
-    }
-
-    if (command === 'commit') {
-      if (commitOptionConsumesNextValue(value)) {
-        skipNext = true;
-        continue;
-      }
-
-      if (commitOptionContainsInlineValue(value)) {
-        continue;
-      }
-    }
-
-    if (value === '--no-verify') return true;
-
-    // Para commit, -n es el atajo de --no-verify.
-    if (command === 'commit' && isCommitNoVerifyShortFlag(value)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Comprueba si la entrada contiene una anulacion -c core.hooksPath=.
- */
-function hasHooksPathOverride(input, detected) {
-  const tokens = tokenizeShellWords(input, detected.gitEnd, detected.commandStart);
-
-  for (let i = 0; i < tokens.length; i++) {
-    const value = tokens[i].value;
-    // Los nombres de seccion + variable de la configuracion de git no
-    // distinguen mayusculas, asi que un intento de bypass como
-    // `core.HOOKSPATH=...` o `core.hookspath=...` debe compararse contra el
-    // token en minusculas.
-    const lowered = value.toLowerCase();
-
-    if (value === '-c') {
-      const next = tokens[i + 1] && tokens[i + 1].value;
-      if (typeof next === 'string' && next.toLowerCase().startsWith(GIT_CONFIG_KEY_PREFIX)) {
-        return true;
-      }
-      i++;
-      continue;
-    }
-
-    if (lowered.startsWith(`-c${GIT_CONFIG_KEY_PREFIX}`)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Analiza una cadena de comando en busca de intentos de bypass de hooks de git.
- */
-function checkCommand(input) {
-  let start = 0;
-
-  while (start < input.length) {
-    const detected = detectGitCommand(input, start);
-    if (!detected) return { blocked: false };
-
-    const { command: gitCommand, offset } = detected;
-
-    if (hasHooksPathOverride(input, detected)) {
-      return {
-        blocked: true,
-        reason: `BLOQUEADO: no se permite anular core.hooksPath con git ${gitCommand}. Los hooks de git no deben omitirse.`,
-      };
-    }
-
-    if (hasNoVerifyFlag(input, gitCommand, offset)) {
-      return {
-        blocked: true,
-        reason: `BLOQUEADO: no se permite el flag --no-verify con git ${gitCommand}. Los hooks de git no deben omitirse.`,
-      };
-    }
-
-    start = findCommandSegmentEnd(input, offset) + 1;
-  }
-
-  return { blocked: false };
-}
-
-/**
- * Extrae la cadena de comando de la entrada del hook (JSON o texto plano).
- */
-function extractCommand(rawInput) {
-  const trimmed = rawInput.trim();
-  if (!trimmed.startsWith('{')) return trimmed;
-
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (typeof parsed !== 'object' || parsed === null) return trimmed;
-
-    // Formato del motor Theus: { tool_input: { command: "..." } }
-    const cmd = parsed.tool_input?.command;
-    if (typeof cmd === 'string') return cmd;
-
-    // Formatos JSON genericos
-    for (const key of ['command', 'cmd', 'input', 'shell', 'script']) {
-      if (typeof parsed[key] === 'string') return parsed[key];
-    }
-
-    return trimmed;
-  } catch {
-    return trimmed;
-  }
-}
-
-/**
- * run() exportable para ejecucion en el mismo proceso via run-with-flags.js.
- */
-function run(rawInput) {
-  const command = extractCommand(rawInput);
-  const result = checkCommand(command);
-
-  if (result.blocked) {
-    return {
-      exitCode: 2,
-      stderr: result.reason,
-    };
-  }
-
-  return { exitCode: 0 };
-}
-
-module.exports = { run };
-
-// Respaldo por stdin para ejecucion via spawnSync — solo cuando se invoca
-// directamente, no via require()
-if (require.main === module) {
-  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 command = extractCommand(raw);
-    const result = checkCommand(command);
-
-    if (result.blocked) {
-      process.stderr.write(result.reason + '\n');
-      process.exit(2);
-    }
-
-    process.stdout.write(raw);
-  });
-}

package/vendor/theus-arsenal/scripts/hooks/check-console-log.js

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Hook Stop: detectar sentencias console.log en archivos modificados
- *
- * Multiplataforma (Windows, macOS, Linux)
- *
- * Se ejecuta despues de cada respuesta y comprueba si algun archivo
- * JavaScript/TypeScript modificado contiene sentencias console.log.
- * Emite avisos para ayudar a recordar eliminar las sentencias de depuracion
- * antes de hacer commit.
- *
- * Exclusiones: archivos de test, archivos de configuracion y el directorio
- * scripts/ (donde console.log suele ser intencional).
- */
-
-const fs = require('fs');
-const { isGitRepo, getGitModifiedFiles, readFile, log } = require('../lib/utils');
-
-// Archivos donde console.log es esperable y no debe generar avisos
-const EXCLUDED_PATTERNS = [
-  /\.test\.[jt]sx?$/,
-  /\.spec\.[jt]sx?$/,
-  /\.config\.[jt]s$/,
-  /scripts\//,
-  /__tests__\//,
-  /__mocks__\//,
-];
-
-const MAX_STDIN = 1024 * 1024; // limite de 1 MB
-let data = '';
-let truncated = false;
-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);
-    if (chunk.length > remaining) truncated = true;
-  } else {
-    truncated = true;
-  }
-});
-
-/**
- * Reenvía stdin de vuelta (convencion de paso directo de Theus) y sale una
- * vez vaciado el pipe. La entrada truncada nunca se reenvía: un documento
- * JSON cortado a mitad de flujo lo reporta el motor como un fallo de
- * validacion JSON del hook Stop.
- */
-function passThroughAndExit() {
-  if (truncated) {
-    log('[Hook] check-console-log: stdin supero 1 MB; se suprime el paso directo (fail-open)');
-    process.exit(0);
-  }
-  if (!data) {
-    process.exit(0);
-  }
-  process.stdout.write(data, () => process.exit(0));
-}
-
-process.stdin.on('end', () => {
-  try {
-    if (!isGitRepo()) {
-      passThroughAndExit();
-      return;
-    }
-
-    const files = getGitModifiedFiles(['\\.tsx?$', '\\.jsx?$'])
-      .filter(f => fs.existsSync(f))
-      .filter(f => !EXCLUDED_PATTERNS.some(pattern => pattern.test(f)));
-
-    let hasConsole = false;
-
-    for (const file of files) {
-      const content = readFile(file);
-      if (content && content.includes('console.log')) {
-        log(`[Hook] AVISO: se encontro console.log en ${file}`);
-        hasConsole = true;
-      }
-    }
-
-    if (hasConsole) {
-      log('[Hook] Elimina las sentencias console.log antes de hacer commit');
-    }
-  } catch (err) {
-    log(`[Hook] error en check-console-log: ${err.message}`);
-  }
-
-  // Siempre reenvía los datos originales (salvo que esten truncados)
-  passThroughAndExit();
-});

package/vendor/theus-arsenal/scripts/hooks/check-hook-enabled.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// Utilidad de linea de comandos: imprime "yes" o "no" segun si un hook esta
-// habilitado bajo THEUS_DISABLED_HOOKS / THEUS_HOOK_PROFILE.
-// Uso: check-hook-enabled.js <hookId> [perfilesCsv]
-
-const { isHookEnabled } = require('../lib/hook-flags');
-
-const [, , hookId, profilesCsv] = process.argv;
-if (!hookId) {
-  process.stdout.write('yes');
-  process.exit(0);
-}
-
-process.stdout.write(isHookEnabled(hookId, { profiles: profilesCsv }) ? 'yes' : 'no');