refacil-sdd-ai 2.6.0 → 2.8.0

package/bin/cli.js

@@ -8,6 +8,11 @@ const {
 } = require('../lib/compact-guidance');
 const compactBash = require('../lib/compact/bash');
 const compactTelemetry = require('../lib/compact/telemetry');
+const busBroker = require('../lib/bus/broker');
+const busSpawn = require('../lib/bus/spawn');
+const busClient = require('../lib/bus/client');
+const busWatch = require('../lib/bus/watch');
+const busPresenter = require('../lib/bus/presenter');
 
 const SKILLS = [
   'setup',
@@ -22,6 +27,13 @@ const SKILLS = [
   'archive',
   'bug',
   'up-code',
+  // refacil-bus (agent chat room)
+  'join',
+  'say',
+  'ask',
+  'reply',
+  'inbox',
+  'attend',
 ];
 
 const packageRoot = path.resolve(__dirname, '..');
@@ -535,31 +547,548 @@ function handleCompactSubcommand(sub) {
 
 function showCompactStats() {
   const s = compactTelemetry.stats();
-  if (s.totalRewrites === 0) {
-    console.log('\n  No hay rewrites registrados todavia. El hook compact-bash aun no se ha disparado o esta deshabilitado.\n');
+  if (s.totalEvents === 0) {
+    console.log('\n  No hay eventos registrados todavia. Ejecuta comandos Bash para generar telemetria de compactacion.\n');
     return;
   }
 
-  const sorted = Object.entries(s.byRule).sort((a, b) => b[1].saved - a[1].saved);
+  const sortedRewrites = Object.entries(s.byRule)
+    .filter(([, data]) => data.rewriteCount > 0)
+    .sort((a, b) => b[1].rewriteSaved - a[1].rewriteSaved);
+  const sortedAlreadyCompact = Object.entries(s.byRule)
+    .filter(([, data]) => data.alreadyCompactCount > 0)
+    .sort((a, b) => b[1].alreadyCompactPotential - a[1].alreadyCompactPotential);
+
+  console.log(`\n  compact-bash stats\n`);
+  console.log(`  Rewrites por hook: ${s.totalRewrites}`);
+  console.log(`  Comandos ya compactos detectados (skill/agente): ${s.totalAlreadyCompact}\n`);
+
+  if (sortedRewrites.length > 0) {
+    console.log('  Ahorro aplicado por hook (rewrite):');
+    for (const [id, data] of sortedRewrites) {
+      const kTokens = (data.rewriteSaved / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.rewriteCount).padStart(6)} rewrites   ~${kTokens.padStart(7)}k tokens`,
+      );
+    }
+    const totalHookK = (s.totalSaved / 1000).toFixed(1);
+    const hookUsd = ((s.totalSaved / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
+    console.log(
+      `    ${'Total hook'.padEnd(18)} ${String(s.totalRewrites).padStart(6)} rewrites   ~${totalHookK.padStart(7)}k tokens (~$${hookUsd} USD)`,
+    );
+    console.log('');
+  }
 
-  console.log(`\n  compact-bash stats (${s.totalRewrites} rewrites en total)\n`);
-  for (const [id, data] of sorted) {
-    const kTokens = (data.saved / 1000).toFixed(1);
+  if (sortedAlreadyCompact.length > 0) {
+    console.log('  Ahorro potencial ya capturado por skill/agente (sin rewrite):');
+    for (const [id, data] of sortedAlreadyCompact) {
+      const kTokens = (data.alreadyCompactPotential / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.alreadyCompactCount).padStart(6)} eventos    ~${kTokens.padStart(7)}k tokens potenciales`,
+      );
+    }
+    const totalAgentK = (s.totalAlreadyCompactPotential / 1000).toFixed(1);
+    const agentUsd = ((s.totalAlreadyCompactPotential / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
     console.log(
-      `    ${id.padEnd(18)} ${String(data.count).padStart(6)} rewrites   ~${kTokens.padStart(7)}k tokens estimados`,
+      `    ${'Total skill'.padEnd(18)} ${String(s.totalAlreadyCompact).padStart(6)} eventos    ~${totalAgentK.padStart(7)}k tokens (~$${agentUsd} USD)`,
     );
+    console.log('');
   }
-  const totalK = (s.totalSaved / 1000).toFixed(1);
-  const costUsd = ((s.totalSaved / 1_000_000) * 3).toFixed(2);
+
+  const totalK = (s.totalObservedPotential / 1000).toFixed(1);
+  const totalUsd = ((s.totalObservedPotential / 1_000_000) * 3).toFixed(2);
   console.log(`    ${'-'.repeat(62)}`);
   console.log(
-    `    ${'Total'.padEnd(18)} ${String(s.totalRewrites).padStart(6)} rewrites   ~${totalK.padStart(7)}k tokens (~$${costUsd} USD, Sonnet input)`,
+    `    ${'Total observado'.padEnd(18)} ${String(s.totalEvents).padStart(6)} eventos    ~${totalK.padStart(7)}k tokens (~$${totalUsd} USD, Sonnet input)`,
   );
   console.log(`\n  Log: ${compactTelemetry.LOG_PATH}`);
   if (compactTelemetry.isDisabled()) {
-    console.log('  Estado: DESHABILITADO (no se registran nuevos rewrites)');
+    console.log('  Estado: DESHABILITADO (no se registran nuevos eventos)');
+  }
+  console.log('');
+}
+
+// --- Bus subcommands (refacil-bus: broker core — fase 1) ---
+
+async function busStart() {
+  try {
+    const { info, started } = await busSpawn.ensureBroker(packageRoot);
+    if (started) {
+      console.log(`  refacil-bus broker iniciado en 127.0.0.1:${info.port} (pid ${info.pid}).`);
+    } else {
+      console.log(`  refacil-bus broker ya estaba activo en 127.0.0.1:${info.port} (pid ${info.pid}).`);
+    }
+  } catch (err) {
+    console.error(`  No se pudo iniciar el broker: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function busStop() {
+  const result = busSpawn.stopBroker();
+  if (result.stopped) {
+    console.log(`  refacil-bus broker detenido (pid ${result.info.pid}).`);
+  } else if (result.reason === 'no-info') {
+    console.log('  refacil-bus broker no está corriendo.');
+  } else if (result.reason === 'not-alive') {
+    console.log('  refacil-bus broker no estaba vivo; info obsoleta limpiada.');
+  } else {
+    console.error(`  No se pudo detener el broker: ${result.reason}`);
+    process.exit(1);
+  }
+}
+
+async function busStatus() {
+  const status = await busSpawn.isBrokerAlive();
+  if (!status.alive) {
+    console.log('  refacil-bus broker: INACTIVO');
+    if (status.staleInfo) {
+      console.log(`  (info obsoleta encontrada: pid ${status.staleInfo.pid}, puerto ${status.staleInfo.port})`);
+    }
+    return;
+  }
+  const info = status.info;
+  const uptimeMs = Date.now() - new Date(info.startedAt).getTime();
+  const uptimeMin = Math.floor(uptimeMs / 60000);
+  console.log('  refacil-bus broker: ACTIVO');
+  console.log(`    host:    127.0.0.1`);
+  console.log(`    puerto:  ${info.port}`);
+  console.log(`    pid:     ${info.pid}`);
+  console.log(`    iniciado: ${info.startedAt}`);
+  console.log(`    uptime:  ${uptimeMin} min`);
+  console.log(`    info:    ${busBroker.BUS_INFO_PATH}`);
+}
+
+function busServe() {
+  // Invocado por spawn detached — ejecuta el broker en foreground.
+  busBroker.start().catch((err) => {
+    process.stderr.write(`Error arrancando broker: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+function parseBusArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token || !token.startsWith('--')) continue;
+    const key = token.slice(2);
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith('--')) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      i++;
+    }
+  }
+  return args;
+}
+
+function defaultSessionName() {
+  return path.basename(process.cwd()) || 'sesion';
+}
+
+async function connectOrDie() {
+  try {
+    const { info } = await busSpawn.ensureBroker(packageRoot);
+    const ws = await busClient.connect(info.port);
+    return { ws, info };
+  } catch (err) {
+    console.error(`  No se pudo conectar al bus: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function formatMessage(m) {
+  const target = m.to ? ` → @${m.to}` : '';
+  return `  [${m.ts}] ${m.from}${target} (${m.kind}): ${m.text}`;
+}
+
+async function busJoin(args) {
+  const session = args.session || defaultSessionName();
+  const room = args.room;
+  const repo = args.repo || process.cwd();
+  let intro = args.intro;
+  if (!intro) {
+    try {
+      intro = busPresenter.buildIntro({ repoDir: repo, session });
+    } catch (_) {
+      intro = `${session} se unió a la sala`;
+    }
+  }
+  if (!room) {
+    console.error('  Uso: refacil-sdd-ai bus join --room <sala> [--session <s>] [--intro "..."]');
+    process.exit(1);
+  }
+  const { ws } = await connectOrDie();
+  const reply = await busClient.sendAndWait(
+    ws,
+    'join',
+    { session, room, repo, intro },
+    (d) => d.type === 'system' && d.event === 'joined',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.error('  Timeout uniéndose a la sala.');
+    process.exit(1);
+  }
+  const members = (reply.detail && reply.detail.members) || [];
+  console.log(`  Unido a la sala "${room}" como "${session}".`);
+  console.log(`  Miembros actuales: ${members.join(', ') || '(solo tú)'}`);
+  console.log(`  Para consultarte: /refacil:ask @${session} "..."`);
+}
+
+async function busLeave(args) {
+  const session = args.session || defaultSessionName();
+  const { ws } = await connectOrDie();
+  const reply = await busClient.sendAndWait(
+    ws,
+    'leave',
+    { session },
+    (d) => d.type === 'system' && (d.event === 'left' || d.event === 'error'),
+    3000,
+  );
+  busClient.close(ws);
+  if (reply && reply.event === 'left') {
+    console.log(`  "${session}" salió de la sala.`);
+  } else {
+    console.log(`  "${session}" no estaba en ninguna sala.`);
+  }
+}
+
+async function busSay(args) {
+  const session = args.session || defaultSessionName();
+  const text = args.text;
+  if (!text) {
+    console.error('  Uso: refacil-sdd-ai bus say --text "..." [--session <s>]');
+    process.exit(1);
+  }
+  const { ws } = await connectOrDie();
+  const reply = await busClient.sendAndWait(
+    ws,
+    'say',
+    { session, text },
+    (d) => d.type === 'system' && (d.event === 'sent' || d.event === 'error'),
+    3000,
+  );
+  busClient.close(ws);
+  if (reply && reply.event === 'sent') {
+    console.log(`  Mensaje enviado (id ${reply.detail.id}).`);
+  } else {
+    const detail = (reply && reply.detail) || 'sin respuesta';
+    console.error(`  No se pudo enviar: ${detail}`);
+    process.exit(1);
+  }
+}
+
+async function busAsk(args) {
+  const session = args.session || defaultSessionName();
+  const to = args.to;
+  const text = args.text;
+  const waitSec = args.wait ? parseInt(args.wait, 10) : 0;
+  if (!to || !text) {
+    console.error('  Uso: refacil-sdd-ai bus ask --to <name> --text "..." [--wait N] [--session <s>]');
+    process.exit(1);
+  }
+  const { ws } = await connectOrDie();
+  const ack = await busClient.sendAndWait(
+    ws,
+    'ask',
+    { session, to: to.replace(/^@/, ''), text },
+    (d) => d.type === 'system' && (d.event === 'sent' || d.event === 'error'),
+    3000,
+  );
+  if (!ack || ack.event !== 'sent') {
+    busClient.close(ws);
+    const detail = (ack && ack.detail) || 'sin respuesta';
+    console.error(`  No se pudo enviar la pregunta: ${detail}`);
+    process.exit(1);
+  }
+  const correlationId = ack.detail.correlationId;
+  console.log(`  Pregunta enviada a @${to.replace(/^@/, '')} (correlationId ${correlationId}).`);
+
+  if (waitSec > 0) {
+    console.log(`  Esperando respuesta hasta ${waitSec}s...`);
+    const resp = await busClient.sendAndWait(
+      ws,
+      'ping',
+      {},
+      (d) => d.type === 'msg' && d.kind === 'reply' && d.correlationId === correlationId,
+      waitSec * 1000,
+    );
+    busClient.close(ws);
+    if (!resp) {
+      console.log(`  Sin respuesta en ${waitSec}s. Usa /refacil:inbox más tarde para recuperarla.`);
+      return;
+    }
+    console.log(`  Respuesta de @${resp.from}:`);
+    console.log(`    ${resp.text}`);
+  } else {
+    busClient.close(ws);
+    console.log('  Usa /refacil:inbox para ver respuestas.');
+  }
+}
+
+async function busReply(args) {
+  const session = args.session || defaultSessionName();
+  const text = args.text;
+  const correlationId = args.correlation || null;
+  const to = args.to ? args.to.replace(/^@/, '') : null;
+  if (!text) {
+    console.error('  Uso: refacil-sdd-ai bus reply --text "..." [--to <name>] [--correlation <id>]');
+    process.exit(1);
   }
+  const { ws } = await connectOrDie();
+  const reply = await busClient.sendAndWait(
+    ws,
+    'reply',
+    { session, text, to, correlationId },
+    (d) => d.type === 'system' && (d.event === 'sent' || d.event === 'error'),
+    3000,
+  );
+  busClient.close(ws);
+  if (reply && reply.event === 'sent') {
+    console.log(`  Respuesta enviada (id ${reply.detail.id}).`);
+  } else {
+    const detail = (reply && reply.detail) || 'sin respuesta';
+    console.error(`  No se pudo responder: ${detail}`);
+    process.exit(1);
+  }
+}
+
+async function busHistory(args) {
+  const session = args.session || defaultSessionName();
+  const n = args.n ? parseInt(args.n, 10) : 20;
+  const { ws } = await connectOrDie();
+  const reply = await busClient.sendAndWait(
+    ws,
+    'history',
+    { session, n },
+    (d) => d.type === 'history',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.log('  Sin historial.');
+    return;
+  }
+  const msgs = reply.messages || [];
+  if (msgs.length === 0) {
+    console.log('  Sin historial.');
+    return;
+  }
+  console.log(`  Últimos ${msgs.length} mensajes:`);
+  for (const m of msgs) console.log(formatMessage(m));
+}
+
+async function busInbox(args) {
+  const session = args.session || defaultSessionName();
+  const { ws } = await connectOrDie();
+  const reply = await busClient.sendAndWait(
+    ws,
+    'inbox',
+    { session },
+    (d) => d.type === 'inbox',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.log('  Sin respuesta del broker.');
+    return;
+  }
+  const msgs = reply.messages || [];
+  if (msgs.length === 0) {
+    console.log('  Sin mensajes nuevos.');
+    return;
+  }
+  console.log(`  ${msgs.length} mensaje(s) nuevo(s):`);
+  for (const m of msgs) console.log(formatMessage(m));
+}
+
+function findFirstUnansweredAsk(messages, session) {
+  const asks = messages.filter((m) => m.kind === 'ask' && m.to === session);
+  for (const ask of asks) {
+    const hasReply = messages.some(
+      (m) => m.kind === 'reply' && m.correlationId === ask.correlationId,
+    );
+    if (!hasReply) return ask;
+  }
+  return null;
+}
+
+function printAttendQuestion(msg) {
+  console.log('  Pregunta recibida del bus:');
+  console.log(`    de:             @${msg.from}`);
+  console.log(`    correlationId:  ${msg.correlationId || '(sin id)'}`);
+  console.log(`    texto:          ${msg.text}`);
   console.log('');
+  console.log('  Responde con: /refacil:reply "<respuesta>"');
+  console.log('  Luego vuelve a ejecutar /refacil:attend para seguir escuchando.');
+}
+
+async function busAttend(args) {
+  const session = args.session || defaultSessionName();
+  const timeoutSec = args.timeout ? parseInt(args.timeout, 10) : 540;
+  const { ws } = await connectOrDie();
+
+  // 1) Revisar preguntas pendientes en el historial antes de suscribirse al push.
+  const hist = await busClient.sendAndWait(
+    ws,
+    'history',
+    { session, n: 50 },
+    (d) => d.type === 'history',
+    3000,
+  );
+  if (hist) {
+    const pending = findFirstUnansweredAsk(hist.messages || [], session);
+    if (pending) {
+      busClient.close(ws);
+      printAttendQuestion(pending);
+      return;
+    }
+  }
+
+  // 2) Suscribirse y esperar push de ask dirigido a esta sesión.
+  const result = await new Promise((resolve) => {
+    let done = false;
+    const finish = (v) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      ws.removeListener('message', onMessage);
+      resolve(v);
+    };
+    const onMessage = (raw) => {
+      let data;
+      try { data = JSON.parse(raw.toString()); } catch (_) { return; }
+      if (data.type === 'msg' && data.kind === 'ask' && data.to === session) {
+        finish({ kind: 'message', msg: data });
+      }
+    };
+    ws.on('message', onMessage);
+    const timer = setTimeout(() => finish({ kind: 'timeout' }), timeoutSec * 1000);
+    busClient.send(ws, 'attend', { session });
+  });
+
+  busClient.close(ws);
+
+  if (result.kind === 'message') {
+    printAttendQuestion(result.msg);
+  } else {
+    console.log(`  Sin preguntas en ${timeoutSec}s. Re-ejecuta /refacil:attend para seguir escuchando.`);
+  }
+}
+
+function readPersistedSessions() {
+  try {
+    return JSON.parse(fs.readFileSync(busBroker.SESSIONS_PATH, 'utf8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+async function busWatchCmd(positional, args) {
+  const session = args.session || positional || null;
+  let room = args.room || null;
+  if (session && !room) {
+    const persisted = readPersistedSessions();
+    if (persisted[session] && persisted[session].room) {
+      room = persisted[session].room;
+    }
+  }
+  if (!session && !room) {
+    console.error('  Uso: refacil-sdd-ai bus watch <session> [--room <sala>]');
+    process.exit(1);
+  }
+  try {
+    const { info } = await busSpawn.ensureBroker(packageRoot);
+    await busWatch.start({ session, room, port: info.port });
+  } catch (err) {
+    console.error(`  No se pudo iniciar el watch: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function busRooms() {
+  const { ws } = await connectOrDie();
+  const reply = await busClient.sendAndWait(
+    ws,
+    'status',
+    {},
+    (d) => d.type === 'system' && d.event === 'status',
+    3000,
+  );
+  busClient.close(ws);
+  if (!reply) {
+    console.log('  Sin respuesta del broker.');
+    return;
+  }
+  const rooms = (reply.detail && reply.detail.rooms) || {};
+  const names = Object.keys(rooms);
+  if (names.length === 0) {
+    console.log('  No hay salas activas.');
+    return;
+  }
+  console.log('  Salas activas:');
+  for (const name of names) {
+    const members = rooms[name] || [];
+    console.log(`    ${name} (${members.length}): ${members.join(', ')}`);
+  }
+}
+
+function handleBusSubcommand(sub) {
+  const rest = process.argv.slice(4);
+  const positional = rest.length > 0 && !rest[0].startsWith('--') ? rest[0] : null;
+  const args = parseBusArgs(rest);
+  switch (sub) {
+    case 'start':
+      busStart();
+      break;
+    case 'stop':
+      busStop();
+      break;
+    case 'status':
+      busStatus();
+      break;
+    case 'serve':
+      busServe();
+      break;
+    case 'join':
+      busJoin(args);
+      break;
+    case 'leave':
+      busLeave(args);
+      break;
+    case 'say':
+      busSay(args);
+      break;
+    case 'ask':
+      busAsk(args);
+      break;
+    case 'reply':
+      busReply(args);
+      break;
+    case 'history':
+      busHistory(args);
+      break;
+    case 'inbox':
+      busInbox(args);
+      break;
+    case 'rooms':
+      busRooms();
+      break;
+    case 'watch':
+      busWatchCmd(positional, args);
+      break;
+    case 'attend':
+      busAttend(args);
+      break;
+    default:
+      console.log('Uso: refacil-sdd-ai bus <start|stop|status|serve|join|leave|say|ask|reply|history|inbox|rooms|watch|attend>');
+  }
 }
 
 function help() {
@@ -573,10 +1102,25 @@ function help() {
     check-review  Verifica que el review se haya completado (usado por hook PreToolUse)
     compact-bash  Reescribe comandos Bash bare para reducir tokens (usado por hook PreToolUse)
     compact       Subcomandos del hook compact-bash:
-                    compact stats      - Estadisticas de rewrites y ahorro estimado
+                    compact stats      - Estadisticas completas (hook + ya-compacto) y ahorro estimado
                     compact disable    - Desactiva el rewrite temporalmente
                     compact enable     - Re-activa el rewrite
                     compact clear-log  - Borra el log historico
+    bus           Subcomandos del chat room entre agentes (refacil-bus):
+                    bus start          - Arranca el broker local (auto-spawn detached)
+                    bus stop           - Detiene el broker
+                    bus status         - Muestra puerto, pid, uptime del broker
+                    bus serve          - (interno) Ejecuta el broker en foreground
+                    bus join --room <sala> [--session <s>] [--intro "..."]
+                    bus leave [--session <s>]
+                    bus say --text "..." [--session <s>]
+                    bus ask --to <name> --text "..." [--wait N] [--session <s>]
+                    bus reply --text "..." [--correlation <id>] [--to <name>]
+                    bus history [--n N] [--session <s>]
+                    bus inbox [--session <s>]
+                    bus rooms
+                    bus watch <session> [--room <sala>]  (panel en vivo, sin tokens)
+                    bus attend [--timeout N]             (escucha preguntas dirigidas)
     clean         Elimina skills y remueve hooks SDD-AI de .claude/settings.json
     help          Muestra esta ayuda
 
@@ -615,6 +1159,9 @@ switch (command) {
   case 'compact':
     handleCompactSubcommand(process.argv[3]);
     break;
+  case 'bus':
+    handleBusSubcommand(process.argv[3]);
+    break;
   case 'clean':
     clean();
     break;