theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/scripts/hooks/seguimiento-costos.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+/**
+ * Hook de Stop (fin de respuesta) - Seguimiento de costos
+ *
+ * Multiplataforma (Windows, macOS, Linux)
+ *
+ * Lee el JSON del evento Stop por stdin (el motor de Theus provee
+ * session_id, transcript_path y cwd), suma el uso de tokens de todos los
+ * turnos del asistente en el transcript JSONL de la sesión
+ * (~/.theus/projects/...) y añade una fila a
+ * <raíz de datos del agente>/metrics/costs.jsonl — el archivo que consume
+ * el comando /informe-costos.
+ *
+ * Comportamiento acumulado: Stop se dispara tras cada respuesta del
+ * asistente, no una vez por sesión. Cada fila representa por lo tanto el
+ * total acumulado de la sesión hasta ese momento. Para el costo por sesión
+ * se toma la última fila por session_id; para el gasto por día se agrega
+ * (es lo que hace /informe-costos).
+ *
+ * Forma de las entradas del asistente en el JSONL del transcript:
+ *   { type: "assistant", message: { model, usage: { input_tokens,
+ *     output_tokens, cache_creation_input_tokens, cache_read_input_tokens } } }
+ *
+ * El modelo se registra tal cual venga en el transcript; las tarifas de
+ * estimación viven en scripts/lib/cost-estimate.js como datos internos.
+ *
+ * Degradación con gracia: sin transcript, sin datos o con stdin roto,
+ * termina con exit 0 en silencio. Jamás bloquea el cierre de la respuesta.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveAgentDataHome } = require('../lib/agent-data-home');
+const { ensureDir, appendFile } = require('../lib/utils');
+const { sanitizeSessionId } = require('../lib/session-bridge');
+const { estimateCostWithCache } = require('../lib/cost-estimate');
+
+function toNumber(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/**
+ * Recorre el JSONL de la sesión y suma el uso de tokens de todos los turnos
+ * del asistente.
+ * @param {string} transcriptPath
+ * @returns {{inputTokens: number, outputTokens: number, cacheWriteTokens: number, cacheReadTokens: number, model: string}|null}
+ *   Totales de uso, o null si el transcript no se pudo leer.
+ */
+function sumUsageFromTranscript(transcriptPath) {
+  let content;
+  try {
+    content = fs.readFileSync(transcriptPath, 'utf8');
+  } catch {
+    return null;
+  }
+
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheWriteTokens = 0;
+  let cacheReadTokens = 0;
+  let model = 'unknown';
+
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (entry.type !== 'assistant') continue;
+    const msg = entry.message;
+    if (!msg || !msg.usage) continue;
+
+    const u = msg.usage;
+    inputTokens += toNumber(u.input_tokens);
+    outputTokens += toNumber(u.output_tokens);
+    cacheWriteTokens += toNumber(u.cache_creation_input_tokens);
+    cacheReadTokens += toNumber(u.cache_read_input_tokens);
+
+    if (msg.model && msg.model !== 'unknown') model = msg.model;
+  }
+
+  return { inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, model };
+}
+
+// Leer la entrada del hook por stdin. Tope de 1 MB: el payload de Stop
+// incluye last_assistant_message, que puede ser grande; nunca se reemite
+// stdin por stdout, así que truncar aquí es inocuo.
+const MAX_STDIN = 1024 * 1024;
+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', () => {
+  try {
+    let input = {};
+    try {
+      input = raw.trim() ? JSON.parse(raw) : {};
+    } catch {
+      input = {};
+    }
+
+    const transcriptPath =
+      typeof input.transcript_path === 'string' && input.transcript_path ? input.transcript_path : null;
+
+    const sessionId = sanitizeSessionId(input.session_id) || 'default';
+
+    let usageTotals = null;
+    if (transcriptPath && fs.existsSync(transcriptPath)) {
+      usageTotals = sumUsageFromTranscript(transcriptPath);
+    }
+
+    const {
+      inputTokens = 0,
+      outputTokens = 0,
+      cacheWriteTokens = 0,
+      cacheReadTokens = 0,
+      model = 'unknown'
+    } = usageTotals || {};
+
+    const estimatedCostUsd = estimateCostWithCache(model, {
+      inputTokens,
+      outputTokens,
+      cacheWriteTokens,
+      cacheReadTokens
+    });
+
+    const metricsDir = path.join(resolveAgentDataHome(), 'metrics');
+    ensureDir(metricsDir);
+
+    // Esquema de la fila: el mismo que documenta commands/informe-costos.md.
+    const row = {
+      timestamp: new Date().toISOString(),
+      session_id: sessionId,
+      transcript_path: transcriptPath || '',
+      model,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cache_write_tokens: cacheWriteTokens,
+      cache_read_tokens: cacheReadTokens,
+      estimated_cost_usd: estimatedCostUsd
+    };
+
+    appendFile(path.join(metricsDir, 'costs.jsonl'), `${JSON.stringify(row)}\n`);
+  } catch {
+    // No bloqueante: el seguimiento de costos jamás debe frenar el cierre.
+  }
+
+  process.exit(0);
+});

package/vendor/theus-arsenal/scripts/hooks/session-end.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+/**
+ * Hook de Stop (fin de respuesta) - Persistir aprendizajes durante sesiones activas
+ *
+ * Multiplataforma (Windows, macOS, Linux)
+ *
+ * Se ejecuta en eventos Stop (después de cada respuesta). Extrae un resumen
+ * significativo del transcript de la sesión (vía transcript_path del JSON de
+ * stdin) y actualiza un archivo de sesión para dar continuidad entre sesiones.
+ * El motor de Theus provee session_id y transcript_path por stdin.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { getSessionsDir, getDateString, getTimeString, sanitizeSessionId, getProjectName, ensureDir, readFile, writeFile, runCommand, stripAnsi, log } = require('../lib/utils');
+const { generateSessionSummary, getContextRemainingPct, getContextThreshold } = require('../lib/llm-summary');
+
+const SUMMARY_START_MARKER = '<!-- THEUS:SUMMARY:START -->';
+const SUMMARY_END_MARKER = '<!-- THEUS:SUMMARY:END -->';
+const SESSION_SEPARATOR = '\n---\n';
+
+/**
+ * Extrae un resumen significativo del transcript de la sesión.
+ * Lee el transcript JSONL y obtiene la información clave:
+ * - Mensajes del usuario (tareas solicitadas)
+ * - Herramientas utilizadas
+ * - Archivos modificados
+ */
+function extractSessionSummary(transcriptPath) {
+  const content = readFile(transcriptPath);
+  if (!content) return null;
+
+  const lines = content.split('\n').filter(Boolean);
+  const userMessages = [];
+  const toolsUsed = new Set();
+  const filesModified = new Set();
+  let parseErrors = 0;
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+
+      // Recolectar mensajes del usuario (primeros 200 caracteres de cada uno)
+      if (entry.type === 'user' || entry.role === 'user' || entry.message?.role === 'user') {
+        // Soporta tanto contenido directo como message.content anidado (formato JSONL de Theus)
+        const rawContent = entry.message?.content ?? entry.content;
+        const text = typeof rawContent === 'string' ? rawContent : Array.isArray(rawContent) ? rawContent.map(c => (c && c.text) || '').join(' ') : '';
+        const cleaned = stripAnsi(text).trim();
+        if (cleaned) {
+          userMessages.push(cleaned.slice(0, 200));
+        }
+      }
+
+      // Recolectar nombres de herramientas y archivos modificados (entradas tool_use directas)
+      if (entry.type === 'tool_use' || entry.tool_name) {
+        const toolName = entry.tool_name || entry.name || '';
+        if (toolName) toolsUsed.add(toolName);
+
+        const filePath = entry.tool_input?.file_path || entry.input?.file_path || '';
+        if (filePath && (toolName === 'Edit' || toolName === 'Write')) {
+          filesModified.add(filePath);
+        }
+      }
+
+      // Extraer usos de herramientas desde los bloques de contenido del asistente (formato JSONL de Theus)
+      if (entry.type === 'assistant' && Array.isArray(entry.message?.content)) {
+        for (const block of entry.message.content) {
+          if (block.type === 'tool_use') {
+            const toolName = block.name || '';
+            if (toolName) toolsUsed.add(toolName);
+
+            const filePath = block.input?.file_path || '';
+            if (filePath && (toolName === 'Edit' || toolName === 'Write')) {
+              filesModified.add(filePath);
+            }
+          }
+        }
+      }
+    } catch {
+      parseErrors++;
+    }
+  }
+
+  if (parseErrors > 0) {
+    log(`[SessionEnd] Se omitieron ${parseErrors}/${lines.length} líneas no parseables del transcript`);
+  }
+
+  if (userMessages.length === 0) return null;
+
+  return {
+    userMessages: userMessages.slice(-10), // Últimos 10 mensajes del usuario
+    toolsUsed: Array.from(toolsUsed).slice(0, 20),
+    filesModified: Array.from(filesModified).slice(0, 30),
+    totalMessages: userMessages.length
+  };
+}
+
+// Leer la entrada del hook por stdin (el motor de Theus provee session_id y
+// transcript_path vía JSON en stdin)
+const MAX_STDIN = 1024 * 1024;
+let stdinData = '';
+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);
+  }
+});
+
+process.stdin.on('end', () => {
+  runMain();
+});
+
+function runMain() {
+  main().catch(err => {
+    console.error('[SessionEnd] Error:', err.message);
+    process.exit(0);
+  });
+}
+
+function getSessionMetadata() {
+  const branchResult = runCommand('git rev-parse --abbrev-ref HEAD');
+
+  return {
+    project: getProjectName() || 'unknown',
+    branch: branchResult.success ? branchResult.output : 'unknown',
+    worktree: process.cwd()
+  };
+}
+
+function extractHeaderField(header, label) {
+  const match = header.match(new RegExp(`\\*\\*${escapeRegExp(label)}:\\*\\*\\s*(.+)$`, 'm'));
+  return match ? match[1].trim() : null;
+}
+
+function buildSessionHeader(today, currentTime, metadata, existingContent = '') {
+  const headingMatch = existingContent.match(/^#\s+.+$/m);
+  const heading = headingMatch ? headingMatch[0] : `# Sesión: ${today}`;
+  const date = extractHeaderField(existingContent, 'Fecha') || today;
+  const started = extractHeaderField(existingContent, 'Inicio') || currentTime;
+
+  return [
+    heading,
+    `**Fecha:** ${date}`,
+    `**Inicio:** ${started}`,
+    `**Última actualización:** ${currentTime}`,
+    `**Proyecto:** ${metadata.project}`,
+    `**Rama:** ${metadata.branch}`,
+    `**Worktree:** ${metadata.worktree}`,
+    ''
+  ].join('\n');
+}
+
+function mergeSessionHeader(content, today, currentTime, metadata) {
+  const separatorIndex = content.indexOf(SESSION_SEPARATOR);
+  if (separatorIndex === -1) {
+    return null;
+  }
+
+  const existingHeader = content.slice(0, separatorIndex);
+  const body = content.slice(separatorIndex + SESSION_SEPARATOR.length);
+  const nextHeader = buildSessionHeader(today, currentTime, metadata, existingHeader);
+  return `${nextHeader}${SESSION_SEPARATOR}${body}`;
+}
+
+async function main() {
+  // Parsear el JSON de stdin para obtener session_id y transcript_path.
+  // El motor de Theus siempre los provee por stdin en eventos Stop;
+  // no existe fallback por variables de entorno.
+  let transcriptPath = null;
+  let sessionId = null;
+  try {
+    const input = JSON.parse(stdinData);
+    if (input && typeof input.transcript_path === 'string' && input.transcript_path.length > 0) {
+      transcriptPath = input.transcript_path;
+    }
+    if (input && typeof input.session_id === 'string' && input.session_id.length > 0) {
+      sessionId = input.session_id;
+    }
+  } catch {
+    // Stdin malformado: continuar sin transcript ni session_id.
+  }
+
+  const sessionsDir = getSessionsDir();
+  const today = getDateString();
+  // Derivar shortId con la convención de últimos 8 caracteres. Prioridad:
+  //   1. session_id recibido por stdin (fuente canónica del motor de Theus)
+  //   2. UUID del nombre del archivo de transcript
+  //   3. 'default'
+  // Cada sesión mapea a un nombre de archivo único basado en su propio
+  // identificador. Sin esto, una sesión padre y cualquier subproceso lanzado
+  // por otro hook de Stop compartirían el nombre de archivo de reserva del
+  // proyecto, y el subproceso sobrescribiría el resumen del padre.
+  let shortId = null;
+  if (sessionId) {
+    shortId = sanitizeSessionId(sessionId.slice(-8).toLowerCase());
+  }
+  if (!shortId && transcriptPath) {
+    const m = path.basename(transcriptPath).match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+    if (m) {
+      shortId = sanitizeSessionId(m[1].slice(-8).toLowerCase());
+    }
+  }
+  if (!shortId) {
+    shortId = 'default';
+  }
+  const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
+  const sessionMetadata = getSessionMetadata();
+
+  ensureDir(sessionsDir);
+
+  const currentTime = getTimeString();
+
+  // Intentar extraer el resumen del transcript
+  let summary = null;
+
+  if (transcriptPath) {
+    if (fs.existsSync(transcriptPath)) {
+      summary = extractSessionSummary(transcriptPath);
+    } else {
+      log(`[SessionEnd] Transcript no encontrado: ${transcriptPath}`);
+    }
+  }
+
+  // Decidir si invocar al LLM para un resumen más rico.
+  // Disparadores: contexto restante < 20%, o cada 50 mensajes de usuario como base.
+  let llmSummary = null;
+  if (transcriptPath && summary && fs.existsSync(transcriptPath)) {
+    const contextPct = getContextRemainingPct(transcriptPath);
+    const isContextLow = contextPct !== null && contextPct < getContextThreshold();
+    const interval = parseInt(process.env.THEUS_LLM_SUMMARY_INTERVAL || '50', 10);
+    const safeInterval = Number.isFinite(interval) && interval > 0 ? interval : 50;
+    const isPeriodicTurn = summary.totalMessages > 0 && summary.totalMessages % safeInterval === 0;
+    if (isContextLow || isPeriodicTurn) {
+      log(`[SessionEnd] Resumen LLM activado (contexto: ${contextPct ?? 'desconocido'}%, mensajes: ${summary.totalMessages})`);
+      llmSummary = generateSessionSummary(transcriptPath);
+      if (llmSummary) {
+        log('[SessionEnd] Resumen LLM generado correctamente');
+      } else {
+        log('[SessionEnd] El resumen LLM falló; se usa la extracción mecánica como respaldo');
+      }
+    }
+  }
+
+  if (fs.existsSync(sessionFile)) {
+    const existing = readFile(sessionFile);
+    let updatedContent = existing;
+
+    if (existing) {
+      const merged = mergeSessionHeader(existing, today, currentTime, sessionMetadata);
+      if (merged) {
+        updatedContent = merged;
+      } else {
+        log(`[SessionEnd] No se pudo normalizar el encabezado en ${sessionFile}`);
+      }
+    }
+
+    // Si hay un resumen nuevo, actualizar solo el bloque generado.
+    // Esto mantiene idempotentes las invocaciones repetidas de Stop y
+    // preserva las secciones escritas por el usuario en el mismo archivo.
+    if (summary && updatedContent) {
+      const summaryBlock = llmSummary ? `${SUMMARY_START_MARKER}\n${llmSummary}\n${SUMMARY_END_MARKER}` : buildSummaryBlock(summary);
+
+      // Usar funciones como reemplazo: summaryBlock incrusta texto crudo de
+      // mensajes del usuario, y un argumento de reemplazo tipo cadena
+      // interpreta las secuencias con $ ($&, $$, $`, $', $n). Un $& en un
+      // mensaje del usuario reinyectaría el bloque completo coincidente y
+      // corrompería el resumen persistido. Una función de reemplazo se trata
+      // de forma literal.
+      if (updatedContent.includes(SUMMARY_START_MARKER) && updatedContent.includes(SUMMARY_END_MARKER)) {
+        updatedContent = updatedContent.replace(new RegExp(`${escapeRegExp(SUMMARY_START_MARKER)}[\\s\\S]*?${escapeRegExp(SUMMARY_END_MARKER)}`), () => summaryBlock);
+      } else {
+        // Ruta de migración para archivos creados antes de que existieran los marcadores.
+        updatedContent = updatedContent.replace(
+          /## (?:Resumen de la sesión|Estado actual)[\s\S]*?$/,
+          () => `${summaryBlock}\n\n### Notas para la próxima sesión\n-\n\n### Contexto a cargar\n\`\`\`\n[archivos relevantes]\n\`\`\`\n`
+        );
+      }
+    }
+
+    if (updatedContent) {
+      writeFile(sessionFile, updatedContent);
+    }
+
+    log(`[SessionEnd] Archivo de sesión actualizado: ${sessionFile}`);
+  } else {
+    // Crear un nuevo archivo de sesión
+    const block = llmSummary ? `${SUMMARY_START_MARKER}\n${llmSummary}\n${SUMMARY_END_MARKER}` : summary ? buildSummaryBlock(summary) : null;
+    const summarySection = block
+      ? `${block}\n\n### Notas para la próxima sesión\n-\n\n### Contexto a cargar\n\`\`\`\n[archivos relevantes]\n\`\`\``
+      : `## Estado actual\n\n[El contexto de la sesión va aquí]\n\n### Completado\n- [ ]\n\n### En progreso\n- [ ]\n\n### Notas para la próxima sesión\n-\n\n### Contexto a cargar\n\`\`\`\n[archivos relevantes]\n\`\`\``;
+
+    const template = `${buildSessionHeader(today, currentTime, sessionMetadata)}${SESSION_SEPARATOR}${summarySection}
+`;
+
+    writeFile(sessionFile, template);
+    log(`[SessionEnd] Archivo de sesión creado: ${sessionFile}`);
+  }
+
+  process.exit(0);
+}
+
+function buildSummarySection(summary) {
+  let section = '## Resumen de la sesión\n\n';
+
+  // Tareas (a partir de mensajes del usuario — se colapsan saltos de línea y
+  // se escapan backticks para no romper el markdown)
+  section += '### Tareas\n';
+  for (const msg of summary.userMessages) {
+    section += `- ${msg.replace(/\n/g, ' ').replace(/`/g, '\\`')}\n`;
+  }
+  section += '\n';
+
+  // Archivos modificados
+  if (summary.filesModified.length > 0) {
+    section += '### Archivos modificados\n';
+    for (const f of summary.filesModified) {
+      section += `- ${f}\n`;
+    }
+    section += '\n';
+  }
+
+  // Herramientas utilizadas
+  if (summary.toolsUsed.length > 0) {
+    section += `### Herramientas utilizadas\n${summary.toolsUsed.join(', ')}\n\n`;
+  }
+
+  section += `### Estadísticas\n- Total de mensajes del usuario: ${summary.totalMessages}\n`;
+
+  return section;
+}
+
+function buildSummaryBlock(summary) {
+  return `${SUMMARY_START_MARKER}\n${buildSummarySection(summary).trim()}\n${SUMMARY_END_MARKER}`;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}