refacil-sdd-ai 2.7.0 → 2.8.1

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, '..');
@@ -113,6 +125,42 @@ function createCursorRules() {
   );
 }
 
+const REPO_VERSION_FILES = ['.claude/.sdd-version', '.cursor/.sdd-version'];
+
+function readRepoVersion(rootDir) {
+  for (const rel of REPO_VERSION_FILES) {
+    const p = path.join(rootDir, rel);
+    try {
+      const raw = fs.readFileSync(p, 'utf8').trim();
+      if (raw) return raw;
+    } catch (_) {
+      // continuar al siguiente
+    }
+  }
+  return null;
+}
+
+function writeRepoVersion(rootDir, version) {
+  for (const rel of REPO_VERSION_FILES) {
+    const p = path.join(rootDir, rel);
+    const parent = path.dirname(p);
+    if (!fs.existsSync(parent)) continue;
+    try {
+      fs.writeFileSync(p, String(version) + '\n');
+    } catch (_) {
+      // tolerante
+    }
+  }
+}
+
+function getPackageVersion() {
+  try {
+    return require(path.join(packageRoot, 'package.json')).version;
+  } catch (_) {
+    return null;
+  }
+}
+
 function removeSkills() {
   let removed = 0;
   for (const skill of SKILLS) {
@@ -292,9 +340,39 @@ function uninstallHook() {
 
 // --- Check update ---
 
+function repoIsInitialized() {
+  return (
+    fs.existsSync(path.join(projectRoot, '.claude', 'skills')) ||
+    fs.existsSync(path.join(projectRoot, '.cursor', 'skills'))
+  );
+}
+
+function syncRepoSkillsIfStale(globalVersion) {
+  // Si el paquete global ya está en globalVersion pero este repo tiene skills
+  // de una versión anterior (porque otro repo disparó el auto-upgrade), hay
+  // que re-copiarlas aquí. Idem si nunca se marcó la versión en este repo.
+  if (!repoIsInitialized()) return null;
+  const repoVersion = readRepoVersion(projectRoot);
+  if (repoVersion === globalVersion) return null;
+
+  const { execSync } = require('child_process');
+  const localCli = path.join(packageRoot, 'bin', 'cli.js');
+  try {
+    execSync(`"${process.execPath}" "${localCli}" update`, {
+      encoding: 'utf8',
+      timeout: 30000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    writeRepoVersion(projectRoot, globalVersion);
+    return { from: repoVersion, to: globalVersion };
+  } catch (_) {
+    return { from: repoVersion, to: globalVersion, failed: true };
+  }
+}
+
 function checkUpdate() {
   const { execSync } = require('child_process');
-  const localVersion = require(path.join(packageRoot, 'package.json')).version;
+  const localVersion = getPackageVersion();
 
   // Always ensure AGENTS.md has current compact-guidance block (silent unless error)
   try {
@@ -305,6 +383,24 @@ function checkUpdate() {
     );
   }
 
+  // Paso 1: sincronizar skills del repo actual si quedaron desfasadas respecto
+  // al paquete global (pasa cuando otro repo ya disparó el auto-upgrade).
+  const syncResult = syncRepoSkillsIfStale(localVersion);
+  if (syncResult && !syncResult.failed) {
+    const fromLabel = syncResult.from ? `v${syncResult.from}` : 'version desconocida';
+    console.log(
+      `[refacil-sdd-ai] Skills de este repo sincronizadas (${fromLabel} -> v${syncResult.to}). ` +
+      'Reinicia la sesion de Claude Code o Cursor para detectar los cambios.',
+    );
+  } else if (syncResult && syncResult.failed) {
+    console.log(
+      `[refacil-sdd-ai] Skills de este repo estan desactualizadas respecto al paquete global (v${syncResult.to}) ` +
+      'pero la sincronizacion automatica fallo. Ejecuta manualmente: refacil-sdd-ai update',
+    );
+  }
+
+  // Paso 2: chequear si hay version nueva en npm y, si la hay, actualizar
+  // global + copiar skills al repo actual.
   try {
     const latest = execSync('npm view refacil-sdd-ai version', {
       encoding: 'utf8',
@@ -314,7 +410,6 @@ function checkUpdate() {
 
     if (!latest || latest === localVersion) return;
 
-    // Auto-upgrade: the hook does it itself, LLM only sees the result
     try {
       execSync('npm update -g refacil-sdd-ai', {
         encoding: 'utf8',
@@ -326,11 +421,11 @@ function checkUpdate() {
         timeout: 30000,
         stdio: ['pipe', 'pipe', 'pipe'],
       });
+      writeRepoVersion(projectRoot, latest);
       console.log(
         `[refacil-sdd-ai] La metodologia SDD-AI se actualizo automaticamente de v${localVersion} a v${latest}. Skills y hooks sincronizados.`,
       );
     } catch (_) {
-      // Upgrade failed — inform so the user can do it manually
       console.log(
         `[refacil-sdd-ai] Hay una nueva version disponible (v${localVersion} -> v${latest}) pero la actualizacion automatica fallo. ` +
         `Informa al usuario que ejecute manualmente: npm update -g refacil-sdd-ai && refacil-sdd-ai update`,
@@ -421,6 +516,7 @@ function init() {
   // Install skills
   const count = installSkills();
   console.log(`  ${count} skills instaladas en .claude/skills/ y .cursor/skills/`);
+  writeRepoVersion(projectRoot, getPackageVersion());
 
   // Create or update CLAUDE.md
   if (createClaudeMd()) {
@@ -463,6 +559,7 @@ function update() {
   console.log('\n  refacil-sdd-ai: Actualizando skills...\n');
   const count = installSkills();
   console.log(`  ${count} skills actualizadas en .claude/skills/ y .cursor/skills/`);
+  writeRepoVersion(projectRoot, getPackageVersion());
 
   // Ensure hook is installed (for users updating from versions without hook)
   if (installHook()) {
@@ -598,6 +695,487 @@ function showCompactStats() {
   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() {
   console.log(`
   refacil-sdd-ai — Metodologia SDD-AI con OpenSpec
@@ -613,6 +1191,21 @@ function help() {
                     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
 
@@ -651,6 +1244,9 @@ switch (command) {
   case 'compact':
     handleCompactSubcommand(process.argv[3]);
     break;
+  case 'bus':
+    handleBusSubcommand(process.argv[3]);
+    break;
   case 'clean':
     clean();
     break;