shilo-cli 0.7.0 → 0.9.0

package/src/commands/review.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const { resolveContext } = require('../context');
+
+/**
+ * shilo review [versión] [--aprobado | --reparos | --rechazado] [-m <nota>] [--json]
+ *
+ * Revisión humana (Etapa 4). Sin veredicto, lista quién revisó esa versión y
+ * qué dijo. Con uno, deja constancia. La versión es `actual` si no se dice
+ * otra cosa, o lo que imprime `shilo log` (alcanza un prefijo de 7 caracteres).
+ *
+ * El positional es una versión, no una carpeta: el contexto se resuelve siempre
+ * sobre el directorio actual, igual que en `log`.
+ */
+const FLAGS = { aprobado: 'aprobado', reparos: 'con_reparos', rechazado: 'rechazado' };
+
+const ETIQUETAS = {
+  aprobado: 'aprobado',
+  con_reparos: 'con reparos',
+  rechazado: 'rechazado',
+};
+
+async function review(args) {
+  const version = typeof args._[0] === 'string' && args._[0].trim() ? args._[0].trim() : 'actual';
+  const elegidos = Object.keys(FLAGS).filter((f) => args[f]);
+  if (elegidos.length > 1) {
+    ui.error('Elegí un solo veredicto: --aprobado, --reparos o --rechazado.');
+    return 1;
+  }
+  const verdict = elegidos.length ? FLAGS[elegidos[0]] : null;
+  const note = typeof args.message === 'string' ? args.message.trim() : '';
+
+  if (!verdict && note) {
+    ui.error('La nota va con un veredicto: --aprobado, --reparos o --rechazado.');
+    return 1;
+  }
+  // La 017 lo exige igual; avisarlo acá ahorra un viaje y dice por qué.
+  if (verdict && verdict !== 'aprobado' && !note) {
+    ui.error('Un reparo o un rechazo necesita una nota que diga qué falta: -m "<nota>".');
+    return 1;
+  }
+
+  const ctx = resolveContext({ ...args, _: [] });
+  if (!ctx.ok) return ctx.code;
+  const { projectId, cfg, client, mgr } = ctx;
+
+  let result;
+  try {
+    const creds = await mgr.valid();
+    result = verdict
+      ? await client.review(projectId, { version, verdict, note }, creds)
+      : await client.listReviews(projectId, version, creds);
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  if (args.json) {
+    console.log(JSON.stringify({ projectId, version: result.version, reviews: result.reviews }, null, 2));
+    return 0;
+  }
+
+  const corto = result.version ? String(result.version).slice(0, 8) : version;
+  if (verdict) ui.success(`Revisión registrada: ${ETIQUETAS[verdict]} (${corto}).`);
+
+  ui.info(`Revisiones de ${ui.c.yellow(corto)}`);
+  ui.info('');
+  if (result.reviews.length === 0) {
+    ui.info('Nadie la revisó todavía.');
+    ui.info(ui.c.dim('Para revisarla: shilo review ' + (version === 'actual' ? '' : version + ' ') + '--aprobado'));
+    return 0;
+  }
+  for (const r of result.reviews) {
+    ui.info(`${pintar(r.verdict)}  ${ui.c.bold(sync.describeAuthor(r.reviewer))}  ${ui.c.dim(sync.formatDate(r.reviewed_at))}`);
+    if (r.note) ui.info(`    ${r.note}`);
+  }
+  return 0;
+}
+
+function pintar(verdict) {
+  const texto = ETIQUETAS[verdict] || verdict;
+  if (verdict === 'aprobado') return ui.c.green(texto);
+  if (verdict === 'rechazado') return ui.c.red(texto);
+  return ui.c.yellow(texto);
+}
+
+/** Una marca corta para `shilo log`: la revisión más reciente manda. */
+function marcaDeRevision(reviews) {
+  if (!Array.isArray(reviews) || reviews.length === 0) return '';
+  const ultima = reviews[0];
+  const extra = reviews.length > 1 ? ` +${reviews.length - 1}` : '';
+  return `${pintar(ultima.verdict)} por ${sync.describeAuthor(ultima.reviewer)}${extra}`;
+}
+
+module.exports = review;
+module.exports.marcaDeRevision = marcaDeRevision;

package/src/commands/status.js

@@ -6,19 +6,29 @@ const sync = require('../sync');
 const remote = require('../remote');
 const { resolveContext } = require('../context');
 
+// A partir de cuántos días sin sincronizar se recuerda hacerlo.
+const STALE_DAYS = 30;
+
 /**
  * shilo status [carpeta] [--project <uuid>] [--base-url <url>] [--short] [--json]
  *
- * Comando de sólo lectura: compara la carpeta local contra el remoto SIN bajar
- * contenido y sin escribir nada, ni local ni remoto. Contesta las dos preguntas
- * que uno se hace antes de arrancar a trabajar:
+ * Compara la carpeta local contra el remoto SIN bajar contenido y sin escribir
+ * nada en el servidor. Contesta las preguntas que uno se hace antes de arrancar
+ * a trabajar:
  *
  *   - ¿el remoto tiene cambios que no tengo? (y de quién son)
  *   - ¿tengo cambios locales sin subir?
+ *   - ¿hay algo mío esperando aprobación?
+ *
+ * La comparación es por ruta + tamaño (un listado por carpeta, cero descargas)
+ * y, cuando el tamaño coincide, por el SHA-256 que el remoto publica en el
+ * listado (`sync.refineByHash`): sigue sin bajar nada.
  *
- * La comparación es por ruta + tamaño (un listado por carpeta, cero descargas).
- * Dos archivos del mismo tamaño se reportan como "iguales" aunque su contenido
- * pudiera diferir: para confirmar byte a byte están `shilo diff` y `push`.
+ * Lo único que escribe es `.shilo.json`, y sólo cuando la carpeta coincide
+ * entera con la versión actual: ahí anota la fecha y la `base`. Es el caso de
+ * una propuesta aprobada en la web, que si no dejaba "Al día" al lado de
+ * "última sincronización hace 2 meses" y al push siguiente partiendo de una
+ * base vieja.
  */
 async function status(args) {
   const ctx = resolveContext(args);
@@ -52,15 +62,46 @@ async function status(args) {
   const attribution = await sync.buildAuthorIndex(client, projectId, mgr, { commits: 50 });
   config.persistCredsIfChanged(cfg, mgr.current);
 
-  const me = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
-  const cmp = sync.compareTrees(local.files, tree.files);
+  // 2b) Propuestas abiertas (best-effort: un servidor viejo no las tiene). De
+  //     paso dicen quién soy —con token personal la sesión no lo trae—, si soy
+  //     el dueño, y cuál es la versión actual.
+  let listed = null;
+  try {
+    listed = await client.listProposals(projectId, await mgr.valid(), { state: 'abierta' });
+    config.persistCredsIfChanged(cfg, mgr.current);
+  } catch (_) {
+    listed = null;
+  }
+  const viewer = (listed && listed.viewer) || null;
+
+  const me =
+    cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : viewer ? viewer.id : null;
+  const cmp = sync.refineByHash(sync.compareTrees(local.files, tree.files), {
+    dir,
+    projectId,
+    baseURL,
+  });
 
   // 3) "Detrás del remoto" = lo que otro subió y yo no tengo igual: archivos
   //    que faltan localmente, o que difieren y cambiaron después de mi lastSync.
+  //
+  //    Lo que está ignorado localmente NO cuenta como "atrás": `walkLocal` no
+  //    lo ve, así que quedaría en `onlyRemote` para siempre y el exit 2 —que
+  //    significa "pull antes de trabajar"— se volvería ruido permanente. Se
+  //    informa aparte: que alguien haya subido tu `settings.local.json` importa,
+  //    pero no es trabajo que te falte bajar.
+  const isIgnoredPath = sync.makePathMatcher(dir);
+
   const behind = [];
+  const ignoredRemote = [];
   for (const item of cmp.onlyRemote) {
+    if (isIgnoredPath(item.repoPath)) {
+      ignoredRemote.push({ ...item, kind: 'ignorado local' });
+      continue;
+    }
     behind.push({ ...item, kind: 'falta local' });
   }
+  ignoredRemote.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
   for (const item of cmp.differing) {
     if (sync.changedSinceSync(item.remote, lastSync) !== false) {
       behind.push({ ...item, kind: 'difiere' });
@@ -85,6 +126,34 @@ async function status(args) {
     };
   };
 
+  // 4b) Propuestas abiertas: las mías (esperan aprobación) y, si soy el dueño,
+  //     las de los demás (esperan mi decisión).
+  const openProposals = listed ? listed.proposals : [];
+  const mineOpen = me ? openProposals.filter((p) => p.author_id === me) : [];
+  const othersOpen = viewer && viewer.is_owner ? openProposals.filter((p) => p.author_id !== me) : [];
+  const projectInfo = (listed && listed.project) || null;
+  const owner = projectInfo && projectInfo.owner;
+  const ownerName = owner ? owner.display_name || owner.username : null;
+  const linkTo = (p) =>
+    projectInfo && projectInfo.path
+      ? `${baseURL.replace(/\/+$/, '')}${projectInfo.path}?propuesta=${p.id.slice(0, 8)}`
+      : null;
+
+  // 4c) Carpeta idéntica a la versión actual → anotarlo (ver cabecera).
+  const aligned = behind.length === 0 && ahead.length === 0 && tree.errors.length === 0;
+  let syncedAt = lastSync;
+  if (aligned && listed && listed.main) {
+    const stale = !savedRemote || savedRemote.base !== listed.main || !lastSync;
+    if (stale && remote.touchSync(dir, { projectId, baseURL, base: listed.main })) {
+      syncedAt = new Date().toISOString();
+    }
+  }
+
+  // 4d) Hace cuánto que esta carpeta no se alinea con el proyecto.
+  const daysSinceSync = syncedAt
+    ? Math.floor((Date.now() - new Date(syncedAt).getTime()) / 86400000)
+    : null;
+
   if (asJson) {
     console.log(
       JSON.stringify(
@@ -92,11 +161,16 @@ async function status(args) {
           projectId,
           baseURL,
           dir,
-          lastSync: lastSync || null,
+          lastSync: syncedAt || null,
+          pendingProposals: mineOpen.map((p) => ({ id: p.id, title: p.title, createdAt: p.created_at, url: linkTo(p) })),
+          awaitingMyDecision: othersOpen.map((p) => ({ id: p.id, title: p.title, url: linkTo(p) })),
           remoteFiles: tree.files.length,
           localFiles: local.files.length,
           behind: behind.map((i) => ({ path: i.repoPath, kind: i.kind, lastCommit: decorate(i) })),
           ahead: ahead.map((i) => ({ path: i.repoPath, kind: i.kind })),
+          // Campo aparte a propósito: si fueran parte de `behind`, un script
+          // volvería a leer "estás desactualizado" por algo que nunca vas a bajar.
+          ignoredRemote: ignoredRemote.map((i) => ({ path: i.repoPath })),
           unchanged: cmp.same.length,
           listErrors: tree.errors,
         },
@@ -113,8 +187,8 @@ async function status(args) {
   }
 
   ui.info('');
-  if (lastSync) {
-    ui.info(ui.c.dim(`Última sincronización de esta carpeta: ${sync.formatDate(lastSync)}`));
+  if (syncedAt) {
+    ui.info(ui.c.dim(`Última sincronización de esta carpeta: ${sync.formatDate(syncedAt)}`));
   } else {
     ui.info(
       ui.c.dim(
@@ -125,8 +199,52 @@ async function status(args) {
   }
   ui.info('');
 
+  /** Los ignorados que existen en el remoto: una línea, o la lista con --show-ignored. */
+  const reportIgnored = () => {
+    if (ignoredRemote.length === 0) return;
+    ui.info(
+      ui.c.dim(
+        `${ignoredRemote.length} archivo(s) existen en el remoto pero están ignorados localmente` +
+          (args['show-ignored'] ? ':' : ' (--show-ignored para verlos).')
+      )
+    );
+    if (args['show-ignored']) {
+      for (const item of ignoredRemote) ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(item.repoPath)}`);
+    }
+    ui.info('');
+  };
+
+  /** Propuestas abiertas: lo primero que hay que saber, antes que la lista de archivos. */
+  const reportProposals = () => {
+    if (mineOpen.length > 0) {
+      const who = viewer && viewer.is_owner ? 'tu aprobación' : ownerName ? `la aprobación de ${ownerName}` : 'aprobación';
+      ui.info(ui.c.bold(`Tenés ${mineOpen.length} propuesta(s) esperando ${who}:`));
+      for (const p of mineOpen) {
+        const link = linkTo(p);
+        ui.info(
+          `  ${ui.c.yellow('⧗')} ${p.title || p.id.slice(0, 8)} ${ui.c.dim(`— ${sync.formatDate(p.created_at)}`)}` +
+            (link ? `\n    ${ui.c.cyan(link)}` : '')
+        );
+      }
+      ui.info('');
+    }
+    if (othersOpen.length > 0) {
+      ui.info(ui.c.bold(`${othersOpen.length} propuesta(s) de otras personas esperan tu decisión:`));
+      for (const p of othersOpen) {
+        const by = p.author ? p.author.display_name || p.author.username : 'alguien';
+        const link = linkTo(p);
+        ui.info(`  ${ui.c.yellow('⧗')} ${p.title || p.id.slice(0, 8)} ${ui.c.dim(`— de ${by}`)}` + (link ? `\n    ${ui.c.cyan(link)}` : ''));
+      }
+      ui.info('');
+    }
+  };
+
+  reportProposals();
+
   if (behind.length === 0 && ahead.length === 0) {
-    ui.success(`Al día: ${cmp.same.length} archivo(s) coinciden con el remoto.`);
+    ui.success(`Al día: ${cmp.same.length} archivo(s) coinciden con el proyecto.`);
+    ui.info('');
+    reportIgnored();
     return 0;
   }
 
@@ -148,7 +266,10 @@ async function status(args) {
   }
 
   if (ahead.length > 0) {
-    ui.info(ui.c.bold(`Tenés ${ahead.length} cambio(s) local(es) sin subir:`));
+    ui.info(
+      ui.c.bold(`Tenés ${ahead.length} cambio(s) local(es) que todavía no son parte del proyecto`) +
+        (mineOpen.length > 0 ? ui.c.bold(' (pueden estar en tu propuesta pendiente):') : ui.c.bold(':'))
+    );
     for (const item of ahead) {
       const mark = item.kind === 'nuevo local' ? ui.c.green('+') : ui.c.yellow('~');
       ui.info(`  ${mark} ${item.repoPath}`);
@@ -156,9 +277,11 @@ async function status(args) {
     ui.info('');
   }
 
+  reportIgnored();
+
   ui.info(
     ui.c.dim(
-      `  ${cmp.same.length} sin cambios (por tamaño)   ` +
+      `  ${cmp.same.length} sin cambios   ` +
         `${local.ignored} ignorados   ${local.skipped.length} saltados`
     )
   );
@@ -175,10 +298,21 @@ async function status(args) {
     ui.info(ui.c.dim('Mirá "shilo diff <archivo>" antes de decidir.'));
   } else if (behind.length > 0) {
     ui.info(ui.c.dim('Sugerido: "shilo pull --dry-run" para ver qué bajaría.'));
+  } else if (mineOpen.length > 0) {
+    ui.info(ui.c.dim('Tus cambios ya están guardados: falta que se apruebe la propuesta de arriba.'));
   } else {
     ui.info(ui.c.dim('Sugerido: "shilo push --dry-run" para ver qué subiría.'));
   }
 
+  // Recordatorio: sincronizar seguido da propuestas chicas y fáciles de revisar.
+  if (ahead.length > 0 && daysSinceSync !== null && daysSinceSync >= STALE_DAYS) {
+    ui.info('');
+    ui.warn(
+      `Hace ${daysSinceSync} días que esta carpeta no se sincroniza. Subí seguido: ` +
+        'cuanto más chico el cambio, más fácil de revisar y menos choques con lo de otros.'
+    );
+  }
+
   // Exit code 2 = "estás desactualizado". Útil para encadenar en scripts:
   // `shilo status || echo "bajá antes de trabajar"`.
   return behind.length > 0 ? 2 : 0;