theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/scripts/plan-canvas.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * CLI del Lienzo de planes — abre artefactos de plan en un lienzo de revisión
+ * en el navegador y bloquea a la espera de feedback humano.
+ *
+ *   node scripts/plan-canvas.js open .theus/plans/funcionalidad.plan.md
+ *   node scripts/plan-canvas.js await .theus/plans/funcionalidad.plan.md
+ *   node scripts/plan-canvas.js await <archivo> --reply "Actualicé la sección 3."
+ *   node scripts/plan-canvas.js end <archivo>
+ *   node scripts/plan-canvas.js stop
+ *
+ * Para agentes: `open` retorna de inmediato (el servidor es un proceso
+ * desacoplado); `await` hace long-poll hasta que la persona envía feedback,
+ * un veredicto o termina la sesión, y entonces imprime un payload JSON en
+ * stdout. Las notas de progreso van a stderr para que stdout siga siendo
+ * parseable.
+ */
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const {
+  canonicalizeArtifactPath,
+  createSessionStore,
+  resolveStateDir,
+  sessionKeyFor
+} = require('./lib/plan-canvas/sessions');
+const {
+  DEFAULT_HOST,
+  createPlanCanvasServer,
+  resolveIdleTimeoutMs,
+  resolvePort
+} = require('./lib/plan-canvas/server');
+
+const VERSION = require('../.theus-plugin/plugin.json').version;
+
+function usage() {
+  return [
+    'Lienzo de planes - revisa planes y artefactos HTML en el navegador',
+    '',
+    'Uso:',
+    '  node scripts/plan-canvas.js                      Muestra el estado del servidor y las sesiones',
+    '  node scripts/plan-canvas.js open <archivo>       Abre (o retoma) una sesión de revisión',
+    '  node scripts/plan-canvas.js await <archivo>      Bloquea hasta que la persona envíe feedback',
+    '  node scripts/plan-canvas.js end <archivo>        Termina una sesión como agente',
+    '  node scripts/plan-canvas.js stop                 Apaga el servidor del lienzo',
+    '  node scripts/plan-canvas.js server               Ejecuta el servidor en primer plano',
+    '',
+    'Opciones:',
+    '  open:  --no-open      No lanzar una ventana del navegador',
+    '         --reopen       Reabrir una sesión que el usuario terminó desde el navegador',
+    '  await: --reply <msj>  Mostrar una respuesta del agente en el chat del lienzo antes de esperar',
+    '         --timeout-ms <n>  Devolver {status:"waiting"} tras n ms (solo tests/depuración)',
+    '  server: --port <n> --host <h>',
+    '',
+    'Entorno: THEUS_PLAN_CANVAS_PORT, THEUS_PLAN_CANVAS_STATE_DIR, THEUS_PLAN_CANVAS_IDLE_MS'
+  ].join('\n');
+}
+
+function valueAfter(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && index + 1 < args.length ? args[index + 1] : null;
+}
+
+function serverInfoPath(stateDir) {
+  return path.join(stateDir, 'server.json');
+}
+
+function readServerInfo(stateDir) {
+  try {
+    return JSON.parse(fs.readFileSync(serverInfoPath(stateDir), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function request(port, method, requestPath, body = null) {
+  return new Promise((resolve, reject) => {
+    const payload = body === null ? null : JSON.stringify(body);
+    const req = http.request(
+      {
+        host: DEFAULT_HOST,
+        port,
+        method,
+        path: requestPath,
+        headers: payload
+          ? { 'content-type': 'application/json', 'content-length': Buffer.byteLength(payload) }
+          : {}
+      },
+      res => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve({ statusCode: res.statusCode, body: JSON.parse(data.trim() || '{}') });
+          } catch {
+            resolve({ statusCode: res.statusCode, body: {} });
+          }
+        });
+      }
+    );
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+async function healthCheck(port) {
+  try {
+    const res = await request(port, 'GET', '/health');
+    return res.body && res.body.app === 'theus-plan-canvas' ? res.body : null;
+  } catch {
+    return null;
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Arranca (o reutiliza) el servidor desacoplado del lienzo y devuelve su
+// puerto. Un desajuste de versión tras una actualización del arsenal reinicia
+// el servidor para que navegador y CLI nunca discrepen sobre el protocolo.
+async function ensureServer({ stateDir, port }) {
+  const health = await healthCheck(port);
+  if (health && health.version === VERSION) return port;
+  if (health) {
+    await request(port, 'POST', '/shutdown').catch(() => {});
+    for (let i = 0; i < 20 && (await healthCheck(port)); i++) await sleep(100);
+  }
+  fs.mkdirSync(stateDir, { recursive: true });
+  const logFd = fs.openSync(path.join(stateDir, 'server.log'), 'a');
+  const child = spawn(process.execPath, [__filename, 'server', '--port', String(port)], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env, THEUS_PLAN_CANVAS_STATE_DIR: stateDir }
+  });
+  child.unref();
+  fs.closeSync(logFd);
+  for (let i = 0; i < 50; i++) {
+    await sleep(100);
+    if (await healthCheck(port)) return port;
+  }
+  throw new Error(`el servidor del lienzo no llegó a estar sano en el puerto ${port}; revisa ${path.join(stateDir, 'server.log')}`);
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const [cmd, args] =
+    platform === 'darwin' ? ['open', [url]]
+      : platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+        : ['xdg-open', [url]];
+  try {
+    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function output(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+async function cmdStatus({ stateDir, port }) {
+  const health = await healthCheck(port);
+  if (!health) {
+    return { server: 'no está corriendo', hint: 'abre un artefacto para iniciarlo', stateDir };
+  }
+  const sessions = await request(port, 'GET', '/api/sessions');
+  return { server: `http://${DEFAULT_HOST}:${port}`, version: health.version, sessions: sessions.body.sessions };
+}
+
+async function cmdOpen(file, args, { stateDir, port }) {
+  if (!file) throw new Error('open requiere una ruta de archivo');
+  if (!fs.existsSync(path.resolve(file))) throw new Error(`artefacto no encontrado: ${file}`);
+  await ensureServer({ stateDir, port });
+  const res = await request(port, 'POST', '/api/sessions', {
+    file: path.resolve(file),
+    reopen: args.includes('--reopen')
+  });
+  if (res.statusCode === 409) return res.body;
+  if (res.statusCode !== 200) throw new Error(res.body.error || `open falló (HTTP ${res.statusCode})`);
+  const url = `http://${DEFAULT_HOST}:${port}${res.body.url}`;
+  const launched = args.includes('--no-open') ? false : openBrowser(url);
+  return {
+    status: 'open',
+    url,
+    browser: launched ? 'opened' : 'not opened',
+    next_step:
+      'Ejecuta `node scripts/plan-canvas.js await <archivo>` y déjalo corriendo; retorna cuando la persona envíe feedback, un veredicto o termine la sesión.'
+  };
+}
+
+function awaitRequest(port, file, timeoutMs) {
+  const params = new URLSearchParams({ file });
+  if (timeoutMs !== null) params.set('timeoutMs', String(timeoutMs));
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      { host: DEFAULT_HOST, port, method: 'GET', path: `/api/await?${params}` },
+      res => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data.trim()));
+          } catch {
+            reject(new Error('la respuesta de await no fue JSON (¿se reinició el servidor?) - relanza await; el feedback nunca se pierde'));
+          }
+        });
+      }
+    );
+    req.setTimeout(0);
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function cmdAwait(file, args, { stateDir, port }) {
+  if (!file) throw new Error('await requiere una ruta de archivo');
+  if (!(await healthCheck(port))) {
+    return { status: 'no-server', hint: 'no hay ningún servidor del lienzo corriendo; usa `open` primero', stateDir };
+  }
+  const reply = valueAfter(args, '--reply');
+  if (reply) {
+    const key = sessionKeyFor(canonicalizeArtifactPath(file));
+    await request(port, 'POST', `/api/session/${key}/reply`, { text: reply });
+  }
+  const timeoutRaw = valueAfter(args, '--timeout-ms');
+  const timeoutMs = timeoutRaw === null ? null : Number.parseInt(timeoutRaw, 10) || 0;
+  process.stderr.write('[plan-canvas] esperando feedback humano... deja esto corriendo (relanza si se interrumpe; el feedback encolado nunca se pierde)\n');
+  const result = await awaitRequest(port, path.resolve(file), timeoutMs);
+  if (result.status === 'feedback') {
+    result.next_step = result.sessionEnded
+      ? 'El usuario envió este feedback y terminó la sesión. Atiéndelo y repórtalo en el chat; no reabras el lienzo sin invitación.'
+      : 'Atiende el feedback y luego ejecuta `node scripts/plan-canvas.js await <archivo> --reply "<qué cambiaste>"` para responder en el lienzo y seguir escuchando.';
+  } else if (result.status === 'ended') {
+    result.next_step =
+      result.endedBy === 'user'
+        ? 'El usuario terminó esta revisión. Deja de consultar y entrega las novedades restantes en el chat; no la reabras sin invitación.'
+        : 'Sesión terminada. Deja de consultar.';
+  }
+  return result;
+}
+
+async function cmdEnd(file, { port }) {
+  if (!file) throw new Error('end requiere una ruta de archivo');
+  if (!(await healthCheck(port))) return { status: 'no-server' };
+  const res = await request(port, 'POST', '/api/end', { file: path.resolve(file) });
+  return res.body;
+}
+
+async function cmdStop({ stateDir, port }) {
+  if (!(await healthCheck(port))) return { status: 'not running' };
+  await request(port, 'POST', '/shutdown').catch(() => {});
+  fs.rmSync(serverInfoPath(stateDir), { force: true });
+  return { status: 'stopping' };
+}
+
+async function cmdServer(args, { stateDir, port }) {
+  const portArg = valueAfter(args, '--port');
+  const hostArg = valueAfter(args, '--host');
+  const listenPort = portArg !== null ? Number.parseInt(portArg, 10) : port;
+  const store = createSessionStore({ stateDir });
+  let shuttingDown = false;
+  const shutdown = async code => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    fs.rmSync(serverInfoPath(stateDir), { force: true });
+    await canvas.close().catch(() => {});
+    process.exit(code);
+  };
+  const canvas = createPlanCanvasServer({
+    store,
+    host: hostArg || DEFAULT_HOST,
+    version: VERSION,
+    idleTimeoutMs: resolveIdleTimeoutMs(),
+    onIdleShutdown: () => shutdown(0),
+    log: line => process.stderr.write(`${line}\n`)
+  });
+  const bound = await canvas.listen(listenPort);
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    serverInfoPath(stateDir),
+    JSON.stringify({ pid: process.pid, port: bound.port, version: VERSION, startedAt: new Date().toISOString() }, null, 2)
+  );
+  // Las sesiones restauradas desde disco retoman sus watchers de archivo.
+  for (const session of store.list()) {
+    if (session.status !== 'ended') canvas.watchSession(store.get(session.key));
+  }
+  process.on('SIGINT', () => shutdown(0));
+  process.on('SIGTERM', () => shutdown(0));
+  process.stderr.write(`[plan-canvas] sirviendo en http://${bound.host}:${bound.port}\n`);
+  return new Promise(() => {}); // corre hasta una señal o el apagado por inactividad
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const args = argv.slice();
+  if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(`${usage()}\n`);
+    return 0;
+  }
+  const command = args[0] && !args[0].startsWith('--') ? args.shift() : null;
+  const stateDir = resolveStateDir();
+  // Un servidor en marcha puede estar en un puerto no estándar; confía en su
+  // información registrada.
+  const recorded = readServerInfo(stateDir);
+  const context = { stateDir, port: (recorded && recorded.port) || resolvePort() };
+  try {
+    if (command === null) output(await cmdStatus(context));
+    else if (command === 'open') output(await cmdOpen(args[0], args, context));
+    else if (command === 'await') output(await cmdAwait(args[0], args, context));
+    else if (command === 'end') output(await cmdEnd(args[0], context));
+    else if (command === 'stop') output(await cmdStop(context));
+    else if (command === 'server') await cmdServer(args, context);
+    else {
+      process.stderr.write(`Comando desconocido: ${command}\n\n${usage()}\n`);
+      return 1;
+    }
+    return 0;
+  } catch (error) {
+    output({ error: error.message });
+    return 1;
+  }
+}
+
+if (require.main === module) {
+  main().then(code => {
+    process.exitCode = code;
+  });
+}
+
+module.exports = { main, ensureServer, healthCheck };

package/vendor/theus-arsenal/scripts/setup-package-manager.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+/**
+ * Detector de gestor de paquetes del arsenal de Theus.
+ *
+ * Uso:
+ *   node scripts/setup-package-manager.js --detect
+ *
+ * Resuelve el gestor de paquetes (npm / pnpm / yarn / bun) delegando en
+ * scripts/lib/package-manager.js, que aplica el orden: THEUS_PACKAGE_MANAGER,
+ * .theus/package-manager.json del proyecto, campo packageManager del
+ * package.json, lockfile y configuración global.
+ */
+
+const {
+  getPackageManager,
+  getRunCommand,
+  getExecCommand,
+} = require('./lib/package-manager');
+
+function main() {
+  const args = process.argv.slice(2);
+  const pm = getPackageManager({ cwd: process.cwd() });
+
+  if (args.includes('--json')) {
+    console.log(
+      JSON.stringify(
+        {
+          gestor: pm.name,
+          fuente: pm.source,
+          test: getRunCommand('test'),
+          exec: getExecCommand('vitest'),
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  // --detect (y sin argumentos): salida legible
+  console.log(`Gestor de paquetes detectado: ${pm.name} (fuente: ${pm.source})`);
+  console.log(`  comando de tests:  ${getRunCommand('test')}`);
+  console.log(`  ejecutar binarios (ej. vitest): ${getExecCommand('vitest')}`);
+}
+
+main();

package/vendor/theus-arsenal/scripts/skills-health.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Salud del portafolio de skills del arsenal de Theus.
+ *
+ * Sin flags imprime el informe tabular; con --dashboard (o --panel) muestra
+ * el panel con sparklines, patrones de fallo, enmiendas y versiones. Las
+ * métricas se leen de la raíz de datos del arsenal (~/.theus/arsenal/); si
+ * todavía no hay datos, el informe sale vacío con un mensaje claro (exit 0).
+ */
+
+const { collectSkillHealth, formatHealthReport } = require('./lib/skill-evolution/health');
+const { renderDashboard } = require('./lib/skill-evolution/dashboard');
+
+function showHelp() {
+  console.log(`
+Uso: node scripts/skills-health.js [opciones]
+
+Opciones:
+  --json                  Emite JSON legible por máquina
+  --skills-root <ruta>    Sobrescribe la raíz de skills curadas
+  --learned-root <ruta>   Sobrescribe la raíz de skills aprendidas
+  --imported-root <ruta>  Sobrescribe la raíz de skills importadas
+  --home <ruta>           Sobrescribe la raíz de datos del arsenal
+                          (por defecto ~/.theus/arsenal)
+  --runs-file <ruta>      Sobrescribe la ruta del JSONL de ejecuciones
+  --now <timestamp>       Fija la hora actual para informes deterministas
+  --dashboard             Muestra el panel de salud con gráficas
+  --panel <nombre>        Muestra solo un panel específico
+                          (success-rate, failures, amendments, versions)
+  --warn-threshold <n>    Sensibilidad de detección de declive (por defecto: 0.1)
+  --help                  Muestra esta ayuda
+`);
+}
+
+function requireValue(argv, index, argName) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('--')) {
+    throw new Error(`Falta el valor para ${argName}`);
+  }
+
+  return value;
+}
+
+function parseArgs(argv) {
+  const options = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === '--skills-root') {
+      options.skillsRoot = requireValue(argv, index, '--skills-root');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--learned-root') {
+      options.learnedRoot = requireValue(argv, index, '--learned-root');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--imported-root') {
+      options.importedRoot = requireValue(argv, index, '--imported-root');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--home') {
+      options.homeDir = requireValue(argv, index, '--home');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--runs-file') {
+      options.runsFilePath = requireValue(argv, index, '--runs-file');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--now') {
+      options.now = requireValue(argv, index, '--now');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--warn-threshold') {
+      options.warnThreshold = Number(requireValue(argv, index, '--warn-threshold'));
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--dashboard') {
+      options.dashboard = true;
+      continue;
+    }
+
+    if (arg === '--panel') {
+      options.panel = requireValue(argv, index, '--panel');
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Argumento desconocido: ${arg}`);
+  }
+
+  return options;
+}
+
+function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+
+    if (options.help) {
+      showHelp();
+      process.exit(0);
+    }
+
+    if (options.dashboard || options.panel) {
+      const result = renderDashboard(options);
+      process.stdout.write(options.json ? `${JSON.stringify(result.data, null, 2)}\n` : result.text);
+    } else {
+      const report = collectSkillHealth(options);
+      process.stdout.write(formatHealthReport(report, { json: options.json }));
+    }
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}\n`);
+    process.exit(1);
+  }
+}
+
+main();