theus-cli-linux-arm64 0.2.84

package/vendor/theus-arsenal/scripts/lib/agent-data-home.js

@@ -0,0 +1,96 @@
+/**
+ * Resuelve la raíz de datos del agente Theus (raíz de persistencia de memoria).
+ *
+ * Orden de resolución (sin mutar process.env):
+ *   1. THEUS_AGENT_DATA_HOME — override explícito del usuario (admite `~`).
+ *   2. ~/.theus/arsenal — ubicación por defecto.
+ *
+ * Nota de diseño: THEUS_PLUGIN_DATA se excluye a propósito de la cadena. Ese
+ * directorio solo existe en el entorno de los hooks, pero los mismos datos
+ * (sesiones, alias, estado) también se leen desde comandos y ejecuciones
+ * manuales, donde esa variable no está definida. Usarla partiría los datos en
+ * dos ubicaciones según el contexto de ejecución; ~/.theus/arsenal es estable
+ * en todos los contextos.
+ *
+ * Política de documentación: se documentan los puntos de entrada públicos;
+ * los helpers internos pequeños (p. ej. `expandHomePath`) se dejan sin JSDoc
+ * a propósito, en línea con el resto de módulos de scripts de Theus.
+ */
+
+const path = require('path');
+
+const AGENT_DATA_HOME_ENV = 'THEUS_AGENT_DATA_HOME';
+const PLUGIN_DATA_ENV = 'THEUS_PLUGIN_DATA';
+const DEFAULT_THEUS_DIR_NAME = '.theus';
+const DEFAULT_ARSENAL_DIR_NAME = 'arsenal';
+
+/**
+ * Directorio home para expansión de `~` y rutas por defecto.
+ *
+ * Replica intencionalmente `getHomeDir()` de `scripts/lib/utils.js`
+ * (HOME/USERPROFILE, luego `os.homedir()`). No importar `utils.getHomeDir`
+ * aquí: `utils.js` ya requiere este módulo (`resolveAgentDataHome`), lo que
+ * crearía una dependencia circular.
+ */
+function getHomeDirFromEnv() {
+  const explicitHome = process.env.HOME || process.env.USERPROFILE;
+  if (explicitHome && String(explicitHome).trim().length > 0) {
+    return path.resolve(explicitHome);
+  }
+  return require('os').homedir();
+}
+
+function expandHomePath(value, baseDir) {
+  if (!value || typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith('~')) {
+    const remainder = trimmed.slice(1).replace(/^[/\\]+/, '');
+    return remainder ? path.join(getHomeDirFromEnv(), remainder) : getHomeDirFromEnv();
+  }
+  if (path.isAbsolute(trimmed)) {
+    return path.resolve(trimmed);
+  }
+  const base = baseDir && String(baseDir).trim()
+    ? path.resolve(baseDir)
+    : process.cwd();
+  return path.resolve(base, trimmed);
+}
+
+function getDefaultAgentDataHome() {
+  return path.join(getHomeDirFromEnv(), DEFAULT_THEUS_DIR_NAME, DEFAULT_ARSENAL_DIR_NAME);
+}
+
+/**
+ * Resuelve la raíz de datos del agente sin mutar process.env.
+ */
+function resolveAgentDataHome() {
+  const fromEnv = expandHomePath(process.env[AGENT_DATA_HOME_ENV]);
+  if (fromEnv) return fromEnv;
+
+  return getDefaultAgentDataHome();
+}
+
+/**
+ * Fija THEUS_AGENT_DATA_HOME en el proceso actual cuando no está definida
+ * (red de seguridad para subprocesos de hooks).
+ * @returns {string} Raíz de datos del agente resuelta
+ */
+function ensureAgentDataHomeEnv() {
+  const resolved = resolveAgentDataHome();
+  if (!expandHomePath(process.env[AGENT_DATA_HOME_ENV])) {
+    process.env[AGENT_DATA_HOME_ENV] = resolved;
+  }
+  return resolved;
+}
+
+module.exports = {
+  AGENT_DATA_HOME_ENV,
+  PLUGIN_DATA_ENV,
+  DEFAULT_THEUS_DIR_NAME,
+  DEFAULT_ARSENAL_DIR_NAME,
+  expandHomePath,
+  getDefaultAgentDataHome,
+  resolveAgentDataHome,
+  ensureAgentDataHomeEnv,
+};

package/vendor/theus-arsenal/scripts/lib/cost-estimate.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Estimación de costos compartida para los hooks del arsenal Theus.
+ *
+ * Tarifas aproximadas por millón de tokens (USD), datos internos de
+ * estimación. Los nombres de familia de modelos de esta tabla son datos de
+ * referencia de tarifas upstream, no copy visible: el registro guarda el
+ * modelo tal cual venga en el transcript y estas tarifas solo sirven para
+ * calcular una cifra estimada.
+ *
+ * Escritura en caché: 1.25x la tarifa de entrada. Lectura de caché: 0.1x.
+ * Los modelos que no coinciden con ninguna familia usan la tarifa media
+ * (fila `sonnet`) como valor conservador por defecto.
+ */
+
+const RATE_TABLE = {
+  haiku: { in: 0.8, out: 4.0, cacheWrite: 1.0, cacheRead: 0.08 },
+  sonnet: { in: 3.0, out: 15.0, cacheWrite: 3.75, cacheRead: 0.3 },
+  opus: { in: 15.0, out: 75.0, cacheWrite: 18.75, cacheRead: 1.5 }
+};
+
+/**
+ * Devuelve la fila de tarifas aplicable a un nombre de modelo.
+ * @param {string} model - Nombre del modelo tal cual aparece en el transcript
+ * @returns {{in: number, out: number, cacheWrite: number, cacheRead: number}}
+ */
+function getRates(model) {
+  const normalized = String(model || '').toLowerCase();
+  if (normalized.includes('haiku')) return RATE_TABLE.haiku;
+  if (normalized.includes('opus')) return RATE_TABLE.opus;
+  return RATE_TABLE.sonnet;
+}
+
+/**
+ * Estima el costo en USD a partir de los tokens de entrada/salida.
+ * @param {string} model - Nombre del modelo
+ * @param {number} inputTokens
+ * @param {number} outputTokens
+ * @returns {number} Costo estimado en USD (redondeado a 6 decimales)
+ */
+function estimateCost(model, inputTokens, outputTokens) {
+  const rates = getRates(model);
+  const cost = (inputTokens / 1_000_000) * rates.in + (outputTokens / 1_000_000) * rates.out;
+  return Math.round(cost * 1e6) / 1e6;
+}
+
+/**
+ * Estima el costo en USD incluyendo los tokens de caché.
+ * @param {string} model - Nombre del modelo
+ * @param {{inputTokens?: number, outputTokens?: number, cacheWriteTokens?: number, cacheReadTokens?: number}} usage
+ * @returns {number} Costo estimado en USD (redondeado a 6 decimales)
+ */
+function estimateCostWithCache(model, usage) {
+  const rates = getRates(model);
+  const u = usage || {};
+  const num = v => (Number.isFinite(Number(v)) ? Number(v) : 0);
+  const cost =
+    (num(u.inputTokens) / 1_000_000) * rates.in +
+    (num(u.outputTokens) / 1_000_000) * rates.out +
+    (num(u.cacheWriteTokens) / 1_000_000) * rates.cacheWrite +
+    (num(u.cacheReadTokens) / 1_000_000) * rates.cacheRead;
+  return Math.round(cost * 1e6) / 1e6;
+}
+
+module.exports = { estimateCost, estimateCostWithCache, getRates, RATE_TABLE };

package/vendor/theus-arsenal/scripts/lib/hook-flags.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Controles compartidos para habilitar/deshabilitar hooks.
+ *
+ * Controles:
+ * - THEUS_HOOK_PROFILE=minimal|standard|strict (por defecto: standard)
+ * - THEUS_DISABLED_HOOKS=ids,de,hooks,separados,por,comas
+ */
+
+'use strict';
+
+const VALID_PROFILES = new Set(['minimal', 'standard', 'strict']);
+
+function normalizeId(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function getHookProfile() {
+  const raw = String(process.env.THEUS_HOOK_PROFILE || 'standard').trim().toLowerCase();
+  return VALID_PROFILES.has(raw) ? raw : 'standard';
+}
+
+function getDisabledHookIds() {
+  const raw = String(process.env.THEUS_DISABLED_HOOKS || '');
+  if (!raw.trim()) return new Set();
+
+  return new Set(
+    raw
+      .split(',')
+      .map(v => normalizeId(v))
+      .filter(Boolean)
+  );
+}
+
+function parseProfiles(rawProfiles, fallback = ['standard', 'strict']) {
+  if (!rawProfiles) return [...fallback];
+
+  if (Array.isArray(rawProfiles)) {
+    const parsed = rawProfiles
+      .map(v => String(v || '').trim().toLowerCase())
+      .filter(v => VALID_PROFILES.has(v));
+    return parsed.length > 0 ? parsed : [...fallback];
+  }
+
+  const parsed = String(rawProfiles)
+    .split(',')
+    .map(v => v.trim().toLowerCase())
+    .filter(v => VALID_PROFILES.has(v));
+
+  return parsed.length > 0 ? parsed : [...fallback];
+}
+
+function isDryRun() {
+  return process.env.THEUS_DRY_RUN === '1';
+}
+
+function isHookEnabled(hookId, options = {}) {
+  const id = normalizeId(hookId);
+  if (!id) return true;
+
+  const disabled = getDisabledHookIds();
+  if (disabled.has(id)) {
+    return false;
+  }
+
+  const profile = getHookProfile();
+  const allowedProfiles = parseProfiles(options.profiles);
+  return allowedProfiles.includes(profile);
+}
+
+module.exports = {
+  VALID_PROFILES,
+  normalizeId,
+  getHookProfile,
+  getDisabledHookIds,
+  parseProfiles,
+  isHookEnabled,
+  isDryRun,
+};

package/vendor/theus-arsenal/scripts/lib/llm-summary.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Generador de resúmenes de sesión con LLM
+ *
+ * Usa `theus -p` (el CLI de Theus) para generar resúmenes de sesión ricos y
+ * contextuales a partir de transcripciones JSONL. No requiere clave de API —
+ * reutiliza la propia autenticación del CLI de Theus.
+ *
+ * Guarda anti-recursión: define THEUS_SKIP_LLM_SUMMARY=1 en el entorno del
+ * subproceso para que los hooks Stop disparados por el subproceso NO vuelvan
+ * a entrar en la generación de resúmenes.
+ */
+
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+
+const MAX_TRANSCRIPT_CHARS = 7000;
+const MAX_TURNS = 25;
+const LLM_TIMEOUT_MS = 90000;
+
+/**
+ * Modelo a usar para el resumen. Si THEUS_LLM_SUMMARY_MODEL no está definida,
+ * devuelve null y se deja que el enrutado multimodelo nativo de Theus elija
+ * un modelo económico del catálogo.
+ */
+function getLLMModel() {
+  return process.env.THEUS_LLM_SUMMARY_MODEL || null;
+}
+
+function getContextThreshold() {
+  const raw = parseInt(process.env.THEUS_LLM_SUMMARY_CONTEXT_THRESHOLD || '20', 10);
+  return Number.isFinite(raw) && raw > 0 && raw <= 100 ? raw : 20;
+}
+
+/**
+ * Extrae los últimos MAX_TURNS turnos usuario+asistente de una transcripción JSONL.
+ * Devuelve null cuando la transcripción no existe o no tiene turnos parseables.
+ */
+function extractConversationText(transcriptPath) {
+  let content;
+  try {
+    content = fs.readFileSync(transcriptPath, 'utf8');
+  } catch {
+    return null;
+  }
+
+  const lines = content.split('\n').filter(Boolean);
+  const turns = [];
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      const isUser = entry.type === 'user' || entry.message?.role === 'user';
+      const isAssistant = entry.type === 'assistant';
+
+      if (isUser) {
+        const rawContent = entry.message?.content ?? entry.content;
+        const text =
+          typeof rawContent === 'string'
+            ? rawContent
+            : Array.isArray(rawContent)
+              ? rawContent
+                  .filter(c => c?.type === 'text')
+                  .map(c => c.text)
+                  .join(' ')
+              : '';
+        const cleaned = text.replace(/\n+/g, ' ').trim();
+        if (cleaned) {
+          turns.push({ role: 'Usuario', text: cleaned.slice(0, 400) });
+        }
+      }
+
+      if (isAssistant && Array.isArray(entry.message?.content)) {
+        const textParts = entry.message.content
+          .filter(b => b?.type === 'text')
+          .map(b => b.text)
+          .join(' ')
+          .replace(/\n+/g, ' ')
+          .trim();
+        if (textParts) {
+          turns.push({ role: 'Theus', text: textParts.slice(0, 600) });
+        }
+      }
+    } catch {
+      // Omitir líneas no parseables
+    }
+  }
+
+  if (turns.length === 0) return null;
+
+  const recent = turns.slice(-MAX_TURNS);
+  const formatted = recent.map(t => `**${t.role}:** ${t.text}`).join('\n\n');
+  return formatted.length > MAX_TRANSCRIPT_CHARS ? '...(inicio omitido)\n\n' + formatted.slice(-MAX_TRANSCRIPT_CHARS) : formatted;
+}
+
+/**
+ * Lee el porcentaje de contexto restante a partir del último registro de uso
+ * de una transcripción. Devuelve null cuando no está disponible.
+ */
+function getContextRemainingPct(transcriptPath) {
+  try {
+    const { readLatestContextTokens, resolveContextWindowTokens } = require('./transcript-context');
+    const usage = readLatestContextTokens(transcriptPath);
+    if (!usage) return null;
+    const windowTokens = resolveContextWindowTokens(usage.tokens, usage.model);
+    return Math.round((1 - usage.tokens / windowTokens) * 100);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Genera un resumen de sesión usando `theus -p`.
+ * Devuelve la cadena del resumen, o null si falla o si la guarda
+ * anti-recursión está activa.
+ */
+function generateSessionSummary(transcriptPath) {
+  if (process.env.THEUS_SKIP_LLM_SUMMARY) return null;
+
+  const conversation = extractConversationText(transcriptPath);
+  if (!conversation) return null;
+
+  const prompt = [
+    'A continuación hay un registro de conversación de una sesión de programación con Theus.',
+    'Crea un resumen que ayude a la próxima sesión a entender el contexto rápidamente.',
+    '',
+    '## Prioriza incluir',
+    '- Decisiones de diseño y elecciones tecnológicas tomadas en esta sesión',
+    '- Bugs y problemas resueltos',
+    '- Archivos cambiados o creados, con una breve descripción de los cambios',
+    '- Tareas inconclusas y trabajo a continuar en la próxima sesión',
+    '- Contexto importante que la próxima sesión necesita conocer',
+    '',
+    '## Registro de conversación',
+    conversation,
+    '',
+    '## Formato de salida (solo Markdown, sin preámbulo)',
+    '',
+    '## Resumen de sesión',
+    '',
+    '### Tareas',
+    '(tareas principales trabajadas en esta sesión)',
+    '',
+    '### Decisiones tomadas',
+    '(decisiones de diseño y elecciones tecnológicas)',
+    '',
+    '### Archivos modificados',
+    '(archivos cambiados o creados)',
+    '',
+    '### Temas pendientes',
+    '(tareas inconclusas y trabajo a continuar)',
+    '',
+    '### Contexto para la próxima sesión',
+    '(contexto importante para la próxima sesión)'
+  ].join('\n');
+
+  try {
+    const model = getLLMModel();
+    const args = model ? ['--model', model, '-p'] : ['-p'];
+    const result = spawnSync('theus', args, {
+      input: prompt,
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        THEUSCODE: '',
+        THEUS_SKIP_LLM_SUMMARY: '1'
+      },
+      timeout: LLM_TIMEOUT_MS,
+      shell: process.platform === 'win32'
+    });
+
+    if (result.error || result.status !== 0) {
+      return null;
+    }
+
+    const output = (result.stdout || '').trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { generateSessionSummary, extractConversationText, getContextRemainingPct, getContextThreshold, getLLMModel };

package/vendor/theus-arsenal/scripts/lib/loopback-guard.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Filtro de cabeceras Host/Origin para los servidores HTTP de loopback del
+ * arsenal (p. ej. el Lienzo de planes). Un ataque de DNS rebinding puede
+ * apuntar un hostname controlado por el atacante a 127.0.0.1, así que cada
+ * petición debe presentar una cabecera Host de esta lista de permitidos antes
+ * de que el servidor haga cualquier trabajo.
+ */
+
+const LOOPBACK_HOSTNAMES = new Set(['127.0.0.1', 'localhost', '[::1]', '::1']);
+
+// Extrae la porción de hostname de una cabecera HTTP Host, descartando el
+// puerto. Devuelve null cuando la cabecera falta o está malformada.
+function parseHostHeader(value) {
+  if (!value || typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(/^(\[[^\]]+\]|[^:]+)(?::\d+)?$/);
+  if (!match) return null;
+  return match[1].toLowerCase();
+}
+
+function buildAllowedHostnames(configuredHost) {
+  const set = new Set(LOOPBACK_HOSTNAMES);
+  if (configuredHost) set.add(String(configuredHost).toLowerCase());
+  return set;
+}
+
+function isAllowedHostHeader(hostHeader, allowedHostnames) {
+  const hostname = parseHostHeader(hostHeader);
+  if (!hostname) return false;
+  return allowedHostnames.has(hostname);
+}
+
+// Origin no viene en navegaciones same-origin ni en clientes de CLI; cuando
+// está presente debe resolver a un hostname permitido.
+function isAllowedOrigin(originHeader, allowedHostnames) {
+  if (!originHeader || typeof originHeader !== 'string') return true;
+  try {
+    const url = new URL(originHeader);
+    return allowedHostnames.has(url.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  LOOPBACK_HOSTNAMES,
+  buildAllowedHostnames,
+  isAllowedHostHeader,
+  isAllowedOrigin,
+  parseHostHeader
+};