theus-cli-darwin-x64 0.2.84

package/vendor/theus-arsenal/scripts/hooks/stop-format-typecheck.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Hook Stop: formatea y verifica tipos en lote sobre todos los archivos JS/TS
+ * editados durante esta respuesta.
+ *
+ * Multiplataforma (Windows, macOS, Linux).
+ *
+ * Lee el acumulador escrito por post-edit-accumulator.js y procesa todos los
+ * archivos editados en una sola pasada: agrupa los archivos por raiz de
+ * proyecto para una unica invocacion del formateador por raiz, y agrupa los
+ * .ts/.tsx por directorio de tsconfig para un unico `tsc --noEmit` por
+ * tsconfig. El acumulador se borra al leerlo, de modo que llamadas Stop
+ * repetidas no procesen dos veces los mismos archivos.
+ *
+ * El timeout por lote es proporcional a la cantidad de lotes para que el
+ * total nunca exceda el presupuesto del hook Stop (se reservan 90 s de
+ * margen).
+ *
+ * El id de sesion llega por stdin JSON (campo `session_id`), tal como lo
+ * provee el motor de hooks de Theus en el evento Stop.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const { execFileSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { findProjectRoot, detectFormatter, resolveFormatterBin } = require('../lib/resolve-formatter');
+
+const MAX_STDIN = 1024 * 1024;
+// Presupuesto total en ms reservado para todos los lotes (deja margen bajo el
+// timeout de 300 s del hook Stop)
+const TOTAL_BUDGET_MS = 270_000;
+
+// Caracteres que cmd.exe trata como separadores/operadores cuando se usa
+// shell: true. Incluye espacios y parentesis para proteger rutas del tipo
+// "C:\Users\John Doe\...".
+const UNSAFE_PATH_CHARS = /[&|<>^%!\s()]/;
+
+/** Convierte el texto del acumulador en un arreglo de rutas sin duplicados. */
+function parseAccumulator(raw) {
+  return [...new Set(raw.split('\n').map(l => l.trim()).filter(Boolean))];
+}
+
+/**
+ * Directorio de estado del plugin: <data home del arsenal>/state.
+ * Debe coincidir exactamente con el que usa post-edit-accumulator.js.
+ */
+function getStateDir() {
+  const { resolveAgentDataHome } = require('../lib/agent-data-home');
+  const dir = path.join(resolveAgentDataHome(), 'state');
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+    // Si no se puede crear, se degrada al directorio temporal del sistema
+    return os.tmpdir();
+  }
+  return dir;
+}
+
+/**
+ * Ruta del archivo acumulador para la sesion actual. El id de sesion viene
+ * del payload stdin del evento Stop; si falta, se deriva un id estable del
+ * directorio de trabajo.
+ */
+function getAccumFile(sessionIdFromInput) {
+  const raw =
+    (typeof sessionIdFromInput === 'string' && sessionIdFromInput) ||
+    crypto.createHash('sha1').update(process.cwd()).digest('hex').slice(0, 12);
+  const sessionId = raw.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+  return path.join(getStateDir(), `theus-edited-${sessionId}.txt`);
+}
+
+function formatBatch(projectRoot, files, timeoutMs) {
+  const formatter = detectFormatter(projectRoot);
+  if (!formatter) return;
+
+  const resolved = resolveFormatterBin(projectRoot, formatter);
+  if (!resolved) return;
+
+  const existingFiles = files.filter(f => fs.existsSync(f));
+  if (existingFiles.length === 0) return;
+
+  const fileArgs =
+    formatter === 'biome'
+      ? [...resolved.prefix, 'check', '--write', ...existingFiles]
+      : [...resolved.prefix, '--write', ...existingFiles];
+
+  try {
+    if (process.platform === 'win32' && resolved.bin.endsWith('.cmd')) {
+      if (existingFiles.some(f => UNSAFE_PATH_CHARS.test(f))) {
+        process.stderr.write('[Hook] stop-format-typecheck: lote omitido — la ruta contiene caracteres inseguros\n');
+        return;
+      }
+      const result = spawnSync(resolved.bin, fileArgs, { cwd: projectRoot, shell: true, stdio: 'pipe', timeout: timeoutMs });
+      if (result.error) throw result.error;
+    } else {
+      execFileSync(resolved.bin, fileArgs, { cwd: projectRoot, stdio: ['pipe', 'pipe', 'pipe'], timeout: timeoutMs });
+    }
+  } catch {
+    // Formateador no instalado o fallo — no bloquea
+  }
+}
+
+function findTsConfigDir(filePath) {
+  let dir = path.dirname(filePath);
+  const fsRoot = path.parse(dir).root;
+  let depth = 0;
+  while (dir !== fsRoot && depth < 20) {
+    if (fs.existsSync(path.join(dir, 'tsconfig.json'))) return dir;
+    dir = path.dirname(dir);
+    depth++;
+  }
+  return null;
+}
+
+function typecheckBatch(tsConfigDir, editedFiles, timeoutMs) {
+  const isWin = process.platform === 'win32';
+  const npxBin = isWin ? 'npx.cmd' : 'npx';
+  const args = ['tsc', '--noEmit', '--pretty', 'false'];
+  const opts = { cwd: tsConfigDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: timeoutMs };
+
+  let stdout = '';
+  let stderr = '';
+  let failed = false;
+
+  try {
+    if (isWin) {
+      // Los archivos .cmd requieren shell: true en Windows
+      const result = spawnSync(npxBin, args, { ...opts, shell: true });
+      if (result.error) return; // timeout o binario ausente — no bloquea
+      if (result.status !== 0) {
+        stdout = result.stdout || '';
+        stderr = result.stderr || '';
+        failed = true;
+      }
+    } else {
+      execFileSync(npxBin, args, opts);
+    }
+  } catch (err) {
+    stdout = err.stdout || '';
+    stderr = err.stderr || '';
+    failed = true;
+  }
+
+  if (!failed) return;
+
+  const lines = (stdout + stderr).split('\n');
+  for (const filePath of editedFiles) {
+    const relPath = path.relative(tsConfigDir, filePath);
+    const candidates = new Set([filePath, relPath]);
+    const relevantLines = lines
+      .filter(line => { for (const c of candidates) { if (line.includes(c)) return true; } return false; })
+      .slice(0, 10);
+    if (relevantLines.length > 0) {
+      process.stderr.write(`[Hook] Errores de TypeScript en ${path.basename(filePath)}:\n`);
+      relevantLines.forEach(line => process.stderr.write(line + '\n'));
+    }
+  }
+}
+
+function main(sessionIdFromInput) {
+  const accumFile = getAccumFile(sessionIdFromInput);
+
+  let raw;
+  try {
+    raw = fs.readFileSync(accumFile, 'utf8');
+  } catch {
+    return; // Sin acumulador — no se edito nada en esta respuesta
+  }
+
+  try { fs.unlinkSync(accumFile); } catch { /* mejor esfuerzo */ }
+
+  const files = parseAccumulator(raw);
+  if (files.length === 0) return;
+
+  const byProjectRoot = new Map();
+  for (const filePath of files) {
+    if (!/\.(ts|tsx|js|jsx)$/.test(filePath)) continue;
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) continue;
+    const root = findProjectRoot(path.dirname(resolved));
+    if (!byProjectRoot.has(root)) byProjectRoot.set(root, []);
+    byProjectRoot.get(root).push(resolved);
+  }
+
+  const byTsConfigDir = new Map();
+  for (const filePath of files) {
+    if (!/\.(ts|tsx)$/.test(filePath)) continue;
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) continue;
+    const tsDir = findTsConfigDir(resolved);
+    if (!tsDir) continue;
+    if (!byTsConfigDir.has(tsDir)) byTsConfigDir.set(tsDir, []);
+    byTsConfigDir.get(tsDir).push(resolved);
+  }
+
+  // Reparte el presupuesto en partes iguales entre todos los lotes para que
+  // el total acumulado se mantenga dentro del limite de tiempo del hook Stop
+  // incluso en monorepos grandes.
+  const totalBatches = byProjectRoot.size + byTsConfigDir.size;
+  const perBatchMs = totalBatches > 0 ? Math.floor(TOTAL_BUDGET_MS / totalBatches) : 60_000;
+
+  for (const [root, batch] of byProjectRoot) formatBatch(root, batch, perBatchMs);
+  for (const [tsDir, batch] of byTsConfigDir) typecheckBatch(tsDir, batch, perBatchMs);
+}
+
+/**
+ * Exportado para que run-with-flags.js use require() en lugar de spawnSync,
+ * dejando que el timeout de 300 s de hooks.json gobierne el lote completo.
+ *
+ * @param {string} rawInput - Cadena JSON cruda de stdin (payload del evento Stop)
+ * @returns {string} La entrada original (pass-through)
+ */
+function run(rawInput) {
+  let sessionId = '';
+  try {
+    const input = JSON.parse(rawInput);
+    if (input && typeof input.session_id === 'string') sessionId = input.session_id;
+  } catch {
+    // stdin no era JSON valido — se usa el fallback derivado del cwd
+  }
+  try {
+    main(sessionId);
+  } catch (err) {
+    process.stderr.write(`[Hook] error en stop-format-typecheck: ${err.message}\n`);
+  }
+  return rawInput;
+}
+
+if (require.main === module) {
+  let stdinData = '';
+  let truncated = false;
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (stdinData.length < MAX_STDIN) {
+      const remaining = MAX_STDIN - stdinData.length;
+      stdinData += chunk.substring(0, remaining);
+      if (chunk.length > remaining) truncated = true;
+    } else {
+      truncated = true;
+    }
+  });
+  process.stdin.on('end', () => {
+    const output = run(stdinData);
+    // Nunca reenviar stdin truncado (un JSON invalido se reportaria como
+    // fallo del hook Stop); vaciar stdout antes de salir para que los
+    // payloads grandes no se corten en el buffer del pipe.
+    if (truncated) {
+      process.stderr.write('[Hook] stop-format-typecheck: stdin supero 1 MB; se suprime el pass-through (fail-open)\n');
+      process.exit(0);
+    }
+    if (!output) {
+      process.exit(0);
+    }
+    process.stdout.write(output, () => process.exit(0));
+  });
+}
+
+module.exports = { run, parseAccumulator };

package/vendor/theus-arsenal/scripts/hooks/suggest-compact.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * Sugeridor estrategico de compactacion
+ *
+ * Multiplataforma (Windows, macOS, Linux).
+ *
+ * Se ejecuta en PreToolUse (o periodicamente) para sugerir compactar de
+ * forma manual en intervalos logicos.
+ *
+ * Por que manual en lugar de auto-compactar:
+ * - La compactacion automatica ocurre en puntos arbitrarios, a menudo en
+ *   medio de una tarea
+ * - Compactar de forma estrategica preserva el contexto a traves de fases
+ *   logicas
+ * - Compacta despues de explorar, antes de ejecutar
+ * - Compacta al completar un hito, antes de comenzar el siguiente
+ *
+ * Dos senales:
+ * - Conteo de llamadas a herramientas: la primera en COMPACT_THRESHOLD
+ *   (50 por defecto), luego cada 25.
+ * - Tamano del contexto (senal primaria): el registro `usage` mas reciente
+ *   del asistente en el transcript de la sesion, comparado contra un umbral
+ *   de tokens escalado por ventana (COMPACT_CONTEXT_THRESHOLD; por defecto
+ *   160k en una ventana de 200k, 250k en 1M), recordando de nuevo tras cada
+ *   COMPACT_CONTEXT_INTERVAL tokens de crecimiento (60k por defecto). El
+ *   conteo de herramientas es un proxy debil de la presion sobre la
+ *   ventana: unas pocas lecturas grandes pueden llenarla en muy pocas
+ *   llamadas, y muchas llamadas pequenas pueden superar 50 con la ventana
+ *   casi vacia.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getTempDir,
+  writeFile,
+  readStdinJson,
+  log,
+  output
+} = require('../lib/utils');
+const {
+  readLatestContextTokens,
+  resolveContextWindowTokens,
+  resolveContextThreshold,
+  resolveContextInterval,
+  computeContextBucket,
+  formatWindowLabel
+} = require('../lib/transcript-context');
+
+const COUNTER_FILE_PREFIX = 'theus-tool-count-';
+const CONTEXT_BUCKET_FILE_PREFIX = 'theus-context-bucket-';
+const STATE_FILE_PREFIXES = [COUNTER_FILE_PREFIX, CONTEXT_BUCKET_FILE_PREFIX];
+const DEFAULT_COMPACT_STATE_TTL_DAYS = 14;
+
+function getCounterRetentionDays() {
+  const raw = process.env.COMPACT_STATE_TTL_DAYS;
+  if (!raw) return DEFAULT_COMPACT_STATE_TTL_DAYS;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_COMPACT_STATE_TTL_DAYS;
+}
+
+/**
+ * Barre archivos de estado por sesion que hayan quedado obsoletos en el
+ * directorio temporal.
+ *
+ * Cada sesion escribe `theus-tool-count-<sessionId>` (y, con la senal de
+ * contexto, `theus-context-bucket-<sessionId>`) en el directorio temporal;
+ * nada mas los elimina. Sin una barrida, estos archivos se acumulan uno por
+ * sesion para siempre. Este helper elimina los archivos de estado cuyo
+ * mtime sea mas antiguo que `retentionDays`, preservando los de la sesion
+ * activa (que el llamador esta a punto de reescribir).
+ *
+ * El helper nunca lanza excepciones; segun el contrato de los hooks de
+ * salir siempre con 0, cualquier fallo de sistema de archivos se absorbe y
+ * se registra en stderr.
+ *
+ * @param {string} tempDir - Directorio temporal a barrer.
+ * @param {number} retentionDays - Los archivos mas antiguos que esta cantidad de dias se eliminan.
+ * @param {string[]} currentStateFiles - Rutas absolutas de los archivos de
+ *   estado de la sesion activa; se preservan incondicionalmente.
+ */
+function cleanupOldCounters(tempDir, retentionDays, currentStateFiles) {
+  let entries;
+  try {
+    entries = fs.readdirSync(tempDir, { withFileTypes: true });
+  } catch (err) {
+    log(`[StrategicCompact] Se omite la barrida de contadores; fallo readdir: ${err.message}`);
+    return;
+  }
+
+  const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+  const currentBasenames = new Set(currentStateFiles.map(filePath => path.basename(filePath)));
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!STATE_FILE_PREFIXES.some(prefix => entry.name.startsWith(prefix))) continue;
+    if (currentBasenames.has(entry.name)) continue;
+
+    const fullPath = path.join(tempDir, entry.name);
+    let stats;
+    try {
+      stats = fs.statSync(fullPath);
+    } catch {
+      continue;
+    }
+
+    // Semantica estricta de "mas antiguo que", segun la documentacion: un
+    // archivo cuyo mtime cae exactamente en el limite tiene edad ==
+    // retentionDays, que no es *mas antiguo que* retentionDays, asi que se
+    // preserva. Se usa >= para que solo los archivos estrictamente mas
+    // antiguos (mtimeMs < cutoffMs) lleguen a la eliminacion.
+    if (stats.mtimeMs >= cutoffMs) continue;
+
+    try {
+      fs.rmSync(fullPath, { force: true });
+    } catch (err) {
+      log(`[StrategicCompact] Aviso: no se pudo eliminar el contador obsoleto ${fullPath}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Incrementa y persiste el contador de llamadas a herramientas de la sesion.
+ * Usa lectura+escritura basada en fd para reducir (aunque no eliminar) la
+ * ventana de carrera entre invocaciones concurrentes del hook.
+ */
+function incrementToolCallCount(counterFile) {
+  let count = 1;
+
+  try {
+    const fd = fs.openSync(counterFile, 'a+');
+    try {
+      const buf = Buffer.alloc(64);
+      const bytesRead = fs.readSync(fd, buf, 0, 64, 0);
+      if (bytesRead > 0) {
+        const parsed = parseInt(buf.toString('utf8', 0, bytesRead).trim(), 10);
+        // Acotar a un rango razonable — un archivo corrupto podria contener
+        // valores enormes que pasan Number.isFinite() (p. ej.,
+        // parseInt('9'.repeat(30)) => 1e+29)
+        count = (Number.isFinite(parsed) && parsed > 0 && parsed <= 1000000)
+          ? parsed + 1
+          : 1;
+      }
+      // Truncar y escribir el nuevo valor
+      fs.ftruncateSync(fd, 0);
+      fs.writeSync(fd, String(count), 0);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    // Fallback: usar writeFile si las operaciones con fd fallan
+    writeFile(counterFile, String(count));
+  }
+
+  return count;
+}
+
+/**
+ * Lee el ultimo bucket de contexto por el que esta sesion ya emitio la
+ * sugerencia (-1 cuando aun no se ha emitido o el archivo de estado es
+ * ilegible o esta corrupto).
+ */
+function readLastContextBucket(bucketFile) {
+  try {
+    const parsed = parseInt(fs.readFileSync(bucketFile, 'utf8').trim(), 10);
+    return Number.isInteger(parsed) && parsed >= 0 && parsed <= 1000000 ? parsed : -1;
+  } catch {
+    return -1;
+  }
+}
+
+/**
+ * Construye la sugerencia por tamano de contexto cuando el transcript
+ * muestra que la sesion cruzo a un nuevo bucket de contexto. Devuelve null
+ * cuando la senal esta en silencio (sin transcript, por debajo del umbral,
+ * deshabilitada, o ya emitida para ese bucket).
+ *
+ * Nunca lanza excepciones — cualquier fallo del transcript o del archivo de
+ * estado deshabilita la senal en silencio para que el hook mantenga su
+ * contrato de salir siempre con 0.
+ */
+function buildContextSuggestion(transcriptPath, bucketFile, env) {
+  try {
+    const usage = readLatestContextTokens(transcriptPath);
+    if (!usage) return null;
+
+    const windowTokens = resolveContextWindowTokens(usage.tokens, usage.model);
+    const threshold = resolveContextThreshold(env, windowTokens);
+    if (threshold <= 0) return null; // COMPACT_CONTEXT_THRESHOLD=0 deshabilita
+
+    const interval = resolveContextInterval(env);
+    const bucket = computeContextBucket(usage.tokens, threshold, interval);
+    if (bucket < 0) return null;
+
+    const lastBucket = readLastContextBucket(bucketFile);
+    if (bucket <= lastBucket) return null;
+
+    writeFile(bucketFile, String(bucket));
+
+    const approxTokens = `${Math.round(usage.tokens / 1000)}k`;
+    const percent = Math.round((usage.tokens / windowTokens) * 100);
+    return `[StrategicCompact] Contexto ~${approxTokens} tokens (${percent}% de la ventana de ${formatWindowLabel(windowTokens)}) - considera /compact en el proximo punto logico`;
+  } catch (err) {
+    log(`[StrategicCompact] Senal de contexto omitida: ${err.message}`);
+    return null;
+  }
+}
+
+async function main() {
+  // Theus entrega la entrada del hook por stdin JSON; session_id es el campo
+  // canonico ('default' como fallback) y transcript_path apunta al JSONL del
+  // transcript de la sesion que usa la senal de tamano de contexto.
+  let input = {};
+  try {
+    input = await readStdinJson({ timeoutMs: 1000 });
+  } catch {
+    input = {};
+  }
+
+  const rawSessionId = (input && typeof input.session_id === 'string' && input.session_id)
+    ? input.session_id
+    : 'default';
+  const sessionId = rawSessionId.replace(/[^a-zA-Z0-9_-]/g, '') || 'default';
+  const transcriptPath = (input && typeof input.transcript_path === 'string') ? input.transcript_path : '';
+
+  const tempDir = getTempDir();
+  const counterFile = path.join(tempDir, `${COUNTER_FILE_PREFIX}${sessionId}`);
+  const bucketFile = path.join(tempDir, `${CONTEXT_BUCKET_FILE_PREFIX}${sessionId}`);
+
+  // Barre archivos de estado obsoletos. Barato, absorbe errores y omite los
+  // archivos de la sesion activa. Ver cleanupOldCounters para los detalles.
+  cleanupOldCounters(tempDir, getCounterRetentionDays(), [counterFile, bucketFile]);
+
+  const rawThreshold = parseInt(process.env.COMPACT_THRESHOLD || '50', 10);
+  const threshold = Number.isFinite(rawThreshold) && rawThreshold > 0 && rawThreshold <= 10000
+    ? rawThreshold
+    : 50;
+
+  const count = incrementToolCallCount(counterFile);
+
+  const messages = [];
+
+  // Senal primaria: tamano real del contexto segun el ultimo registro de
+  // usage del transcript. Se dispara en un umbral de tokens escalado por
+  // ventana y solo vuelve a dispararse cuando el contexto crece otro paso
+  // del intervalo.
+  const contextSuggestion = buildContextSuggestion(transcriptPath, bucketFile, process.env);
+  if (contextSuggestion) {
+    messages.push(contextSuggestion);
+  }
+
+  // Senal secundaria: conteo de llamadas a herramientas en el umbral, luego
+  // cada 25 llamadas.
+  if (count === threshold) {
+    messages.push(`[StrategicCompact] ${threshold} llamadas a herramientas alcanzadas - considera /compact si estas cambiando de fase`);
+  } else if (count > threshold && (count - threshold) % 25 === 0) {
+    messages.push(`[StrategicCompact] ${count} llamadas a herramientas - buen punto de control para /compact si el contexto esta desactualizado`);
+  }
+
+  // log() escribe en stderr (log de depuracion). En un hook PreToolUse no
+  // bloqueante (exit 0), stderr solo va al log de depuracion; no llega al
+  // modelo. Para inyectar una sugerencia visible al usuario sin bloquear la
+  // llamada a la herramienta, se emite JSON estructurado a stdout con
+  // hookSpecificOutput.additionalContext — el mecanismo documentado para que
+  // los hooks PreToolUse agreguen contexto al siguiente turno del modelo.
+  // Los hooks deben emitir como maximo un payload JSON por ejecucion, asi
+  // que ambas senales lo comparten.
+  if (messages.length > 0) {
+    for (const msg of messages) {
+      log(msg);
+    }
+    output({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext: messages.join('\n')
+      }
+    });
+  }
+
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[StrategicCompact] Error:', err.message);
+  process.exit(0);
+});