theus-cli-linux-arm64 0.2.84

package/vendor/theus-arsenal/scripts/hooks/config-protection.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+/**
+ * Hook de proteccion de configuracion
+ *
+ * Bloquea modificaciones a archivos de configuracion de linters/formateadores.
+ * Los agentes suelen modificarlos para que las verificaciones pasen en lugar
+ * de corregir el codigo real. Este hook redirige al agente a arreglar el
+ * codigo fuente.
+ *
+ * Codigos de salida:
+ *   0 = permitir (no es un archivo de configuracion, o es su creacion inicial)
+ *   2 = bloquear (se intento modificar un archivo de configuracion existente)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+const PROTECTED_FILES = new Set([
+  // ESLint (config legada + flat config v9, JS/TS/MJS/CJS)
+  '.eslintrc',
+  '.eslintrc.js',
+  '.eslintrc.cjs',
+  '.eslintrc.json',
+  '.eslintrc.yml',
+  '.eslintrc.yaml',
+  'eslint.config.js',
+  'eslint.config.mjs',
+  'eslint.config.cjs',
+  'eslint.config.ts',
+  'eslint.config.mts',
+  'eslint.config.cts',
+  // Prettier (todas las variantes de config, incluida ESM)
+  '.prettierrc',
+  '.prettierrc.js',
+  '.prettierrc.cjs',
+  '.prettierrc.json',
+  '.prettierrc.yml',
+  '.prettierrc.yaml',
+  'prettier.config.js',
+  'prettier.config.cjs',
+  'prettier.config.mjs',
+  // Biome
+  'biome.json',
+  'biome.jsonc',
+  // Ruff (Python)
+  '.ruff.toml',
+  'ruff.toml',
+  // Nota: pyproject.toml NO se incluye aqui de forma intencional porque
+  // contiene metadatos del proyecto junto a la config del linter. Bloquear
+  // todas sus ediciones impediria cambios legitimos de dependencias.
+  // Shell / Style / Markdown
+  '.shellcheckrc',
+  '.stylelintrc',
+  '.stylelintrc.json',
+  '.stylelintrc.yml',
+  '.markdownlint.json',
+  '.markdownlint.yaml',
+  '.markdownlintrc'
+]);
+
+function parseInput(inputOrRaw) {
+  if (typeof inputOrRaw === 'string') {
+    try {
+      return inputOrRaw.trim() ? JSON.parse(inputOrRaw) : {};
+    } catch {
+      return {};
+    }
+  }
+
+  return inputOrRaw && typeof inputOrRaw === 'object' ? inputOrRaw : {};
+}
+
+/**
+ * run() exportable para ejecucion en el mismo proceso via run-with-flags.js.
+ * Evita los ~50-100 ms de sobrecoste de spawnSync cuando esta disponible.
+ */
+function run(inputOrRaw, options = {}) {
+  if (options.truncated) {
+    return {
+      exitCode: 2,
+      stderr:
+        `BLOQUEADO: la entrada del hook supero ${options.maxStdin || MAX_STDIN} bytes. ` +
+        'No se omite la proteccion de configuracion con un payload truncado. ' +
+        'Reintenta con una edicion mas pequena o deshabilita temporalmente el hook config-protection.'
+    };
+  }
+
+  const input = parseInput(inputOrRaw);
+  const filePath = input?.tool_input?.file_path || input?.tool_input?.file || '';
+  if (!filePath) return { exitCode: 0 };
+
+  const basename = path.basename(filePath);
+  if (PROTECTED_FILES.has(basename)) {
+    // Permitir la creacion inicial: no hay config existente que debilitar.
+    // El proposito del hook es bloquear modificaciones; escribir un archivo
+    // de configuracion nuevo en un proyecto que no tiene ninguno es una via
+    // de arranque legitima (p. ej. scaffolding de ESLint en un repo nuevo).
+    //
+    // Fallar cerrado ante cualquier error de stat distinto de ENOENT. Se usa
+    // lstatSync para que un symlink en la ruta protegida se trate como
+    // presente aunque su destino falte: un symlink colgante en, p. ej.,
+    // .eslintrc.js sigue representando una entrada de configuracion
+    // existente que un agente no debe reemplazar en silencio.
+    // fs.existsSync se tragaria EACCES/EPERM como false; lstatSync expone el
+    // codigo de error para tratar como ausente solo el genuino "ruta no
+    // encontrada" (ENOENT).
+    let exists = true;
+    try {
+      fs.lstatSync(filePath);
+      // lstat tuvo exito: algo (archivo, directorio o symlink) existe aqui.
+    } catch (err) {
+      if (err && err.code === 'ENOENT') {
+        exists = false;
+      }
+      // Cualquier otro error (EACCES, EPERM, ELOOP, etc.) deja exists=true
+      // para que la proteccion nunca se debilite en silencio.
+    }
+
+    if (!exists) {
+      return { exitCode: 0 };
+    }
+
+    return {
+      exitCode: 2,
+      stderr:
+        `BLOQUEADO: no se permite modificar ${basename}. ` +
+        'Corrige el codigo fuente para satisfacer las reglas del linter/formateador ' +
+        'en lugar de debilitar la configuracion. Si es un cambio de configuracion ' +
+        'legitimo, deshabilita temporalmente el hook config-protection.'
+    };
+  }
+
+  return { exitCode: 0 };
+}
+
+module.exports = { run };
+
+// Respaldo por stdin para ejecucion via spawnSync
+let truncated = /^(1|true|yes)$/i.test(String(process.env.THEUS_HOOK_INPUT_TRUNCATED || ''));
+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);
+    if (chunk.length > remaining) truncated = true;
+  } else {
+    truncated = true;
+  }
+});
+
+process.stdin.on('end', () => {
+  const result = run(raw, {
+    truncated,
+    maxStdin: Number(process.env.THEUS_HOOK_INPUT_MAX_BYTES) || MAX_STDIN
+  });
+
+  if (result.stderr) {
+    process.stderr.write(result.stderr + '\n');
+  }
+
+  if (result.exitCode === 2) {
+    process.exit(2);
+  }
+
+  process.stdout.write(raw);
+});

package/vendor/theus-arsenal/scripts/hooks/design-quality-check.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * Hook PostToolUse: recordatorio ligero de calidad de diseño frontend.
+ *
+ * Es autocontenido dentro de Theus. No llama a modelos remotos ni instala
+ * paquetes. Su objetivo es detectar deriva hacia UI genérica evidente y
+ * mantener las ediciones de frontend alineadas con los estándares de diseño
+ * más exigentes de Theus.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const FRONTEND_EXTENSIONS = /\.(astro|css|html|jsx|scss|svelte|tsx|vue)$/i;
+const MAX_STDIN = 1024 * 1024;
+
+const GENERIC_SIGNALS = [
+  { pattern: /\bget started\b/i, label: 'copy de CTA "Get Started"' },
+  { pattern: /\blearn more\b/i, label: 'copy de CTA "Learn more"' },
+  { pattern: /\bgrid-cols-(3|4)\b/, label: 'grilla uniforme de múltiples tarjetas' },
+  { pattern: /\bbg-gradient-to-[trbl]/, label: 'uso de utilidad de gradiente de plantilla' },
+  { pattern: /\btext-center\b/, label: 'indicios de layout centrado por defecto' },
+  { pattern: /\bfont-(sans|inter)\b/i, label: 'utilidad de fuente por defecto' },
+];
+
+const CHECKLIST = [
+  'jerarquía visual con contraste real',
+  'ritmo de espaciado intencional',
+  'profundidad, capas o superposición',
+  'estados hover y focus con propósito',
+  'color y tipografía que se sientan específicos',
+];
+
+function getFilePaths(input) {
+  const toolInput = input?.tool_input || {};
+  if (toolInput.file_path) {
+    return [String(toolInput.file_path)];
+  }
+
+  if (Array.isArray(toolInput.edits)) {
+    return toolInput.edits
+      .map(edit => String(edit?.file_path || ''))
+      .filter(Boolean);
+  }
+
+  return [];
+}
+
+function readContent(filePath) {
+  try {
+    return fs.readFileSync(path.resolve(filePath), 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function detectSignals(content) {
+  return GENERIC_SIGNALS.filter(signal => signal.pattern.test(content)).map(signal => signal.label);
+}
+
+function buildWarning(frontendPaths, findings) {
+  const pathLines = frontendPaths.map(fp => `  - ${fp}`).join('\n');
+  const signalLines = findings.length > 0
+    ? findings.map(item => `  - ${item}`).join('\n')
+    : '  - no se detectaron cadenas obvias de plantilla enlatada';
+
+  return [
+    '[Hook] REVISIÓN DE DISEÑO: se modificaron archivos de frontend:',
+    pathLines,
+    '[Hook] Revisa que no haya deriva hacia lo genérico/plantilla. El frontend debe tener:',
+    CHECKLIST.map(item => `  - ${item}`).join('\n'),
+    '[Hook] Señales heurísticas:',
+    signalLines,
+  ].join('\n');
+}
+
+function run(inputOrRaw) {
+  let input;
+  let rawInput = inputOrRaw;
+
+  try {
+    if (typeof inputOrRaw === 'string') {
+      rawInput = inputOrRaw;
+      input = inputOrRaw.trim() ? JSON.parse(inputOrRaw) : {};
+    } else {
+      input = inputOrRaw || {};
+      rawInput = JSON.stringify(inputOrRaw ?? {});
+    }
+  } catch {
+    return { exitCode: 0, stdout: typeof rawInput === 'string' ? rawInput : '' };
+  }
+
+  const filePaths = getFilePaths(input);
+  const frontendPaths = filePaths.filter(filePath => FRONTEND_EXTENSIONS.test(filePath));
+
+  if (frontendPaths.length === 0) {
+    return { exitCode: 0, stdout: typeof rawInput === 'string' ? rawInput : '' };
+  }
+
+  const findings = [];
+  for (const filePath of frontendPaths) {
+    const content = readContent(filePath);
+    findings.push(...detectSignals(content));
+  }
+
+  return {
+    exitCode: 0,
+    stdout: typeof rawInput === 'string' ? rawInput : '',
+    stderr: buildWarning(frontendPaths, findings),
+  };
+}
+
+module.exports = { run };
+
+if (require.main === module) {
+  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);
+    }
+  });
+  process.stdin.on('end', () => {
+    const result = run(raw);
+    if (result.stderr) process.stderr.write(`${result.stderr}\n`);
+    process.stdout.write(typeof result.stdout === 'string' ? result.stdout : raw);
+    process.exit(Number.isInteger(result.exitCode) ? result.exitCode : 0);
+  });
+}

package/vendor/theus-arsenal/scripts/hooks/doc-file-warning.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Hook de aviso por archivos de documentación ad-hoc (PreToolUse - Write)
+ *
+ * Usa un enfoque de lista de denegación: solo avisa ante nombres de archivo
+ * de documentación ad-hoc conocidos (NOTES, TODO, SCRATCH, etc.) fuera de
+ * directorios estructurados. Esto evita falsos positivos en flujos de trabajo
+ * legítimos con mucho markdown (specs, ADRs, definiciones de comandos,
+ * archivos de skills, etc.).
+ *
+ * Código de salida 0 siempre (solo avisa, nunca bloquea).
+ */
+
+'use strict';
+
+const path = require('path');
+const { buildPreToolUseAdditionalContext } = require('./pretooluse-visible-output');
+
+const MAX_STDIN = 1024 * 1024;
+
+// Nombres ad-hoc conocidos que indican archivos improvisados/de borrador
+// (sensible a mayúsculas, solo en mayúsculas)
+const ADHOC_FILENAMES = /^(NOTES|TODO|SCRATCH|TEMP|DRAFT|BRAINSTORM|SPIKE|DEBUG|WIP)\.(md|txt)$/;
+
+// Directorios estructurados donde incluso los nombres ad-hoc son intencionales
+const STRUCTURED_DIRS = /(^|\/)(docs|\.theus|\.github|commands|skills|benchmarks|templates|\.history|memory)\//;
+
+function isSuspiciousDocPath(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const basename = path.basename(normalized);
+
+  // Solo inspecciona archivos .md y .txt (sensible a mayúsculas, consistente con ADHOC_FILENAMES)
+  if (!/\.(md|txt)$/.test(basename)) return false;
+
+  // Solo marca nombres ad-hoc conocidos
+  if (!ADHOC_FILENAMES.test(basename)) return false;
+
+  // Permite nombres ad-hoc dentro de directorios estructurados (uso intencional)
+  if (STRUCTURED_DIRS.test(normalized)) return false;
+
+  return true;
+}
+
+/**
+ * run() exportable para ejecución en el mismo proceso vía run-with-flags.js.
+ * Evita la sobrecarga de ~50-100ms de spawnSync cuando está disponible.
+ */
+function run(inputOrRaw, _options = {}) {
+  let input;
+  try {
+    input = typeof inputOrRaw === 'string'
+      ? (inputOrRaw.trim() ? JSON.parse(inputOrRaw) : {})
+      : (inputOrRaw || {});
+  } catch {
+    return { exitCode: 0 };
+  }
+  const filePath = String(input?.tool_input?.file_path || '');
+
+  if (filePath && isSuspiciousDocPath(filePath)) {
+    return {
+      exitCode: 0,
+      additionalContext: [
+        '[Hook] AVISO: se detectó un nombre de archivo de documentación ad-hoc',
+        `[Hook] Archivo: ${filePath}`,
+        '[Hook] Considera usar una ruta estructurada (p. ej. docs/, .theus/, skills/, .github/, benchmarks/, templates/)',
+      ],
+    };
+  }
+
+  return { exitCode: 0 };
+}
+
+/**
+ * Punto de entrada por stdin para ejecución directa/spawnSync: lee el payload
+ * del hook desde stdin (con tope MAX_STDIN), ejecuta la política y escribe el
+ * resultado PreToolUse en stdout. Solo debe ejecutarse cuando se invoca
+ * directamente, nunca al hacer require(), para no filtrar los listeners de
+ * stdin hacia un proceso padre que cargue este hook en el mismo proceso.
+ */
+function main() {
+  let data = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', c => {
+    if (data.length < MAX_STDIN) {
+      const remaining = MAX_STDIN - data.length;
+      data += c.substring(0, remaining);
+    }
+  });
+
+  process.stdin.on('end', () => {
+    const result = run(data);
+
+    if (result.stderr) {
+      process.stderr.write(result.stderr + '\n');
+    }
+
+    if (Object.prototype.hasOwnProperty.call(result, 'additionalContext')) {
+      process.stdout.write(buildPreToolUseAdditionalContext(result.additionalContext));
+    } else {
+      process.stdout.write(data);
+    }
+  });
+}
+
+module.exports = { run, main };
+
+// Respaldo por stdin para ejecución con spawnSync — solo al invocarse directamente, no vía require()
+if (require.main === module) {
+  main();
+}

package/vendor/theus-arsenal/scripts/hooks/modo-seguro.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Hook PreToolUse del modo seguro (matcher: Bash|Write|Edit).
+ *
+ * Lee el estado en <data home del arsenal>/modo-seguro.json (por defecto
+ * ~/.theus/arsenal/modo-seguro.json, gestionado por el comando /modo-seguro):
+ *
+ *   { "mode": "off" | "cuidadoso" | "congelado" | "guardian",
+ *     "dir": "<directorio permitido para escrituras>",
+ *     "allowReadAll": true,
+ *     "updatedAt": "<ISO UTC>" }
+ *
+ * Comportamiento:
+ *   - "off" o archivo inexistente → permite todo (exit 0).
+ *   - "cuidadoso"  → bloquea los patrones destructivos en comandos Bash.
+ *   - "congelado"  → bloquea Write/Edit fuera del directorio `dir`.
+ *   - "guardian"   → aplica ambas protecciones.
+ *
+ * Bloqueo = exit 2 con el motivo en stderr (español) + registro en
+ * <data home del arsenal>/modo-seguro.log. Cualquier error interno degrada a
+ * permitir (exit 0): la protección nunca debe romper el CLI, y un estado
+ * corrupto equivale a modo off (se avisa por stderr sin bloquear).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { resolveAgentDataHome } = require('../lib/agent-data-home');
+
+const MAX_STDIN = 1024 * 1024;
+
+const MODOS_VALIDOS = new Set(['off', 'cuidadoso', 'congelado', 'guardian']);
+
+/**
+ * Patrones destructivos vigilados en modo cuidadoso/guardian.
+ * Deben mantenerse alineados con la lista documentada en
+ * skills/modo-seguro/SKILL.md.
+ */
+const PATRONES_DESTRUCTIVOS = [
+  { re: /\bsudo\s+rm\b/, motivo: 'sudo rm — borrado con privilegios de administrador' },
+  { re: /\brm\b(?=[^\n|;&]*\s-\w*r)(?=[^\n|;&]*\s-\w*f)/, motivo: 'rm con -r y -f — borrado recursivo forzado' },
+  { re: /\bgit\s+push\b[^\n]*(\s--force(-with-lease)?\b|\s-f\b)/, motivo: 'git push forzado — puede sobrescribir historia remota' },
+  { re: /\bgit\s+reset\s+--hard\b/, motivo: 'git reset --hard — descarta cambios locales sin recuperación' },
+  { re: /\bgit\s+checkout\s+(--\s+)?\.(\s|$)/, motivo: 'git checkout . — descarta todos los cambios del árbol de trabajo' },
+  { re: /\bdrop\s+(table|database)\b/i, motivo: 'DROP TABLE/DATABASE — borrado de datos en la base' },
+  { re: /\bdocker\s+system\s+prune\b/, motivo: 'docker system prune — borra contenedores/imágenes/volúmenes' },
+  { re: /\bkubectl\s+delete\b/, motivo: 'kubectl delete — borra recursos del clúster' },
+  { re: /\bchmod\s+(-\w+\s+)*777\b/, motivo: 'chmod 777 — permisos totalmente abiertos' },
+  { re: /\bnpm\s+publish\b/, motivo: 'npm publish — publicación accidental de paquete' },
+  { re: /--no-verify\b/, motivo: '--no-verify — omite los hooks de verificación' },
+];
+
+function leerStdin() {
+  return new Promise(resolve => {
+    let raw = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => {
+      if (raw.length < MAX_STDIN) raw += chunk.substring(0, MAX_STDIN - raw.length);
+    });
+    process.stdin.on('end', () => resolve(raw));
+    process.stdin.on('error', () => resolve(raw));
+  });
+}
+
+function cargarEstado(dataHome) {
+  const stateFile = path.join(dataHome, 'modo-seguro.json');
+  if (!fs.existsSync(stateFile)) return { mode: 'off' };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    const mode = String(parsed?.mode || 'off').toLowerCase();
+    if (!MODOS_VALIDOS.has(mode)) {
+      process.stderr.write(`[modo-seguro] Modo desconocido "${mode}" en ${stateFile}; se trata como off\n`);
+      return { mode: 'off' };
+    }
+    return { ...parsed, mode };
+  } catch (error) {
+    process.stderr.write(`[modo-seguro] Estado ilegible en ${stateFile} (${error.message}); se trata como off\n`);
+    return { mode: 'off' };
+  }
+}
+
+function registrar(dataHome, entrada) {
+  try {
+    fs.mkdirSync(dataHome, { recursive: true });
+    fs.appendFileSync(
+      path.join(dataHome, 'modo-seguro.log'),
+      `${JSON.stringify({ ts: new Date().toISOString(), ...entrada })}\n`,
+      'utf8',
+    );
+  } catch {
+    // El registro nunca debe impedir el bloqueo ni la ejecución.
+  }
+}
+
+function bloquear(dataHome, estado, detalle, motivo, sugerencia) {
+  registrar(dataHome, { mode: estado.mode, ...detalle, motivo });
+  process.stderr.write(
+    `[modo seguro: ${estado.mode}] Acción bloqueada: ${motivo}.\n` +
+    `${sugerencia}\n` +
+    `Para desactivar las protecciones usa /modo-seguro off.\n`,
+  );
+  process.exit(2);
+}
+
+async function main() {
+  let input = {};
+  try {
+    const raw = (await leerStdin()).trim();
+    if (raw) input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const dataHome = resolveAgentDataHome();
+  const estado = cargarEstado(dataHome);
+  if (estado.mode === 'off') process.exit(0);
+
+  const tool = String(input.tool_name || '');
+  const vigilaComandos = estado.mode === 'cuidadoso' || estado.mode === 'guardian';
+  const vigilaEscrituras = estado.mode === 'congelado' || estado.mode === 'guardian';
+
+  if (tool === 'Bash' && vigilaComandos) {
+    const command = String(input.tool_input?.command || '');
+    for (const patron of PATRONES_DESTRUCTIVOS) {
+      if (patron.re.test(command)) {
+        bloquear(
+          dataHome,
+          estado,
+          { tool, command: command.slice(0, 500) },
+          patron.motivo,
+          'Si de verdad necesitas ejecutarlo, hazlo tú a mano en tu terminal o ajusta el comando a una variante más segura.',
+        );
+      }
+    }
+  }
+
+  if ((tool === 'Write' || tool === 'Edit') && vigilaEscrituras) {
+    const filePath = String(input.tool_input?.file_path || '');
+    if (filePath) {
+      const permitido = path.resolve(String(estado.dir || input.cwd || process.cwd()));
+      const destino = path.resolve(String(input.cwd || process.cwd()), filePath);
+      const relativo = path.relative(permitido, destino);
+      const fuera = relativo === '' ? false : relativo.startsWith('..') || path.isAbsolute(relativo);
+      if (fuera) {
+        bloquear(
+          dataHome,
+          estado,
+          { tool, file: destino },
+          `escritura fuera del directorio permitido (${permitido})`,
+          'Trabaja dentro del directorio permitido o cambia el directorio con /modo-seguro.',
+        );
+      }
+    }
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));