theus-cli-linux-arm64 1.2.2 → 1.4.0

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

@@ -1,341 +0,0 @@
-#!/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

@@ -1,46 +0,0 @@
-#!/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

@@ -1,143 +0,0 @@
-#!/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();