shilo-cli 0.8.0 → 0.10.0

package/README.md

@@ -36,6 +36,7 @@ cd mi-carpeta
 shilo init --project <uuid>       # ata la carpeta al repo (escribe .shilo.json)
 shilo push                        # sube: crea/actualiza + commit
 shilo push -m "mi mensaje"        # con mensaje de commit
+shilo push --deploy prod          # este push despliega a producción ("[deploy: prod]")
 shilo push --dry-run              # muestra qué haría sin subir
 shilo push --card ABC-123         # agrega "[card: ABC-123]" al mensaje del commit
 shilo push --agent claude-code --model claude-opus-5   # lo escribió un agente, y queda anotado
@@ -169,6 +170,57 @@ shilo log --json
 
 La paginación es **por commit**, no por archivo: si un archivo no aparece, subí `-n`.
 
+### Deploys a Vercel (deploys)
+
+Si el owner conectó el proyecto con Vercel (pestaña **Deploys** en la web), cada
+push que cambia algo dispara un deploy: por defecto a **preview**. Producción sólo
+si se pide explícitamente.
+
+```bash
+shilo push --deploy prod        # este push va a producción
+shilo push --deploy off         # este push no despliega
+shilo deploys                   # destino y últimos deploys, con estado y URL
+shilo deploys -n 20 --json
+```
+
+`--deploy` sólo agrega el trailer `[deploy: …]` al mensaje; escribirlo a mano en
+`-m` da lo mismo.
+
+### Respaldar todas las carpetas (sync)
+
+```bash
+shilo sync                      # lista las carpetas conectadas y su último sync
+shilo sync --all                # sube todas, una tras otra
+shilo sync ./boda               # sólo esa carpeta
+shilo sync a4c2                 # o por id de proyecto (alcanza un prefijo)
+shilo sync --scan ~/proyectos   # registra las carpetas ya conectadas que haya ahí
+shilo sync --forget ./vieja     # la saca del registro (no toca el disco)
+shilo sync --all --dry-run      # qué subiría cada una, sin subir nada
+```
+
+El CLI lleva un registro de carpetas conectadas en `~/.shilo/carpetas.json`. Se llena
+solo: cada `init`, `push` o `pull` registra su carpeta. Las que se conectaron antes
+de esta versión se suman una vez con `--scan`, que busca `.shilo.json` hasta 6 niveles
+abajo (no entra en `node_modules`, `.git` ni `dist`).
+
+Sincronizar es **subir**: cada carpeta pasa por `shilo push --yes`, con sus mismas
+garantías (un conflicto queda como propuesta abierta, una carpeta con posibles
+secretos no sube nada). Cada push corre en su propio proceso, así que si una carpeta
+falla las demás siguen, y al final hay un resumen. **Un respaldo no despliega:**
+manda `--deploy off` salvo que pases otro `--deploy`.
+
+**Una carpeta sin `base` se saltea.** `base` es la versión del proyecto sobre la que
+está tu copia; la escriben `push` y `pull`. Sin ella, un push no puede saber si tu
+copia está vieja y subiría tus archivos como cambios, pisando lo más nuevo. Esas
+carpetas aparecen como "requiere atención": revisalas con `shilo status` y
+`shilo diff`, subilas a mano una vez con `shilo push` (o bajá lo nuevo con
+`shilo pull`) y desde ahí entran solas al respaldo.
+
+Exit code 1 = alguna carpeta falló o se salteó. Una propuesta que queda esperando
+aprobación (exit 3 de `push`) cuenta como respaldada. El plan de las etapas
+siguientes (respaldo programado, vista en la web) está en `PLAN_SINCRONIZAR.md` en la
+raíz del repo.
+
 ### Diferencias (diff)
 
 ```bash
@@ -307,6 +359,10 @@ SHILO_TOKEN=<pat> shilo init --project <uuid>   # variable de entorno (lo natura
   manda una propuesta con la base exacta; el servidor la combina con la versión actual
   y nunca pisa un archivo que otra persona cambió. `base` en `.shilo.json`,
   `registerBlob` para binarios, camino viejo sólo como reserva.
+- **Fase 8 — deploys** *(hecho)*: `push --deploy <prod|preview|off>` y
+  `shilo deploys` para el deploy automático a Vercel (PLAN_DEPLOY_VERCEL).
+- **Fase 9 — respaldo** *(Etapa 1 hecha)*: registro de carpetas conectadas y
+  `shilo sync [--all]`. Lo que sigue, en `PLAN_SINCRONIZAR.md`.
 
 ## Exit codes
 
@@ -316,4 +372,5 @@ SHILO_TOKEN=<pat> shilo init --project <uuid>   # variable de entorno (lo natura
 | `diff`   | 1      | Hay diferencias entre local y remoto.        |
 | `pull`   | 1      | Quedaron conflictos sin bajar (o fallas).    |
 | `push`   | 1      | Se detectaron posibles secretos (nada subido). |
+| `sync`   | 1      | Alguna carpeta no se respaldó (falló o se salteó). |
 | cualquiera | 1    | Error.                                       |

package/bin/shilo.js

@@ -24,7 +24,9 @@ ${ui.c.bold('Comandos:')}
   diff [archivo]     Diferencias entre tu copia local y la remota.
   review [versión]   Quién revisó una versión, o dejar tu revisión.
   export <carpeta>   Escribe la historia del proyecto como un repositorio Git.
-  help               Muestra esta ayuda.
+  deploys            Destino e historial de deploys a Vercel del proyecto.
+  sync [carpeta|uuid] Respalda las carpetas conectadas (--all: todas).
+  help              Muestra esta ayuda.
 
 ${ui.c.bold('Opciones de login:')}
   --email <e>        Email (si se omite, se pregunta).
@@ -55,6 +57,7 @@ ${ui.c.bold('Opciones de push:')}
   -m, --message <m>  Mensaje del commit.
   --only <ruta>      Sube sólo esa ruta (archivo o carpeta). Repetible.
   --card <id>        Id de tarjeta/tablero; se agrega al mensaje como [card: id].
+  --deploy <d>       prod | preview | off: pisa el deploy automático de este push.
   --agent <nombre>   Declara que lo escribió un agente (ej: claude-code).
   --model <modelo>   Qué modelo, junto con --agent.
   --session <id>     Id de la conversación, para agrupar guardados.
@@ -62,12 +65,17 @@ ${ui.c.bold('Opciones de push:')}
   --prompt-file <f>  Igual, leyendo el pedido de un archivo (máx. 64 KB).
   --dry-run          Muestra qué haría (y quién tocó cada archivo), sin subir nada.
   --yes              No pide confirmación.
-  --allow-secrets    Sube igual los archivos donde se detectaron posibles secretos.
+  --allow-secrets    Sube igual TODO lo que parezca un secreto (avanzado). Mejor:
+                     responder en la terminal; la decisión queda en .shilo/.
   --concurrency <n>  Requests en paralelo (1-32, default 8; o SHILO_CONCURRENCY).
   --no-index         Ignora el índice local (.shilo/index.json) y recompara todo.
+  --allow-failing-checks
+                     Si falla un chequeo de shilo.config.json, propone igual
+                     (queda marcada como fallida y aplicarla exige forzar).
   --verbose          Lista archivo por archivo en vez de resumir.
   --base-url <url>   Servidor Shilo.
   ${ui.c.dim('Respeta .gitignore y .shiloignore, incluidos los de subcarpetas.')}
+  ${ui.c.dim('Exit code 3 = todo guardado, pero espera aprobación (no es un error).')}
 
 ${ui.c.bold('Opciones de pull:')}
   --project <uuid>   Proyecto origen (pisa el .shilo.json de la carpeta).
@@ -105,6 +113,23 @@ ${ui.c.bold('Opciones de export:')}
   --base-url <url>   Servidor Shilo.
   ${ui.c.dim('La primera vez, a una carpeta vacía; después sólo trae lo nuevo. Público sin sesión.')}
 
+${ui.c.bold('Opciones de deploys:')}
+  -n <N>             Cuántos deploys mostrar (1-20, default 10).
+  --json             Salida JSON.
+  --project <uuid>   Proyecto (pisa el .shilo.json de la carpeta).
+
+${ui.c.bold('Opciones de sync:')}
+  (sin argumentos)   Lista las carpetas conectadas y su último sync.
+  --all              Sube todas las carpetas registradas, una tras otra.
+  --scan [raíz]      Registra las carpetas con .shilo.json bajo raíz (default: la actual).
+  --forget <carpeta> La saca del registro (no toca nada en disco).
+  -m, --message <m>  Mensaje de los commits (default: "Respaldo (shilo sync) <fecha>").
+  --deploy <d>       prod | preview | off (default off: un respaldo no despliega).
+  --dry-run          Muestra qué subiría cada carpeta, sin subir nada.
+  ${ui.c.dim('Se registran solas con init, push o pull. Una carpeta sin "base" en su')}
+  ${ui.c.dim('.shilo.json se saltea: subila a mano una vez con "shilo push".')}
+  ${ui.c.dim('Exit code 1 = alguna carpeta falló o se salteó.')}
+
 ${ui.c.bold('Globales:')}
   -v, --version      Versión del CLI.
   -h, --help         Ayuda.
@@ -122,6 +147,8 @@ const COMMANDS = {
   diff: () => require('../src/commands/diff'),
   review: () => require('../src/commands/review'),
   export: () => require('../src/commands/export'),
+  deploys: () => require('../src/commands/deploys'),
+  sync: () => require('../src/commands/sync'),
 };
 
 async function main() {
@@ -133,6 +160,7 @@ async function main() {
     booleans: [
       'help', 'version', 'h', 'v', 'dry-run', 'yes', 'force', 'push', 'pull',
       'json', 'short', 'stat', 'files', 'allow-secrets', 'no-index', 'verbose',
+      'allow-failing-checks', 'all',
       'show-ignored', 'include-ignored', 'aprobado', 'reparos', 'rechazado',
     ],
     aliases: { h: 'help', v: 'version', m: 'message' },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shilo-cli",
-  "version": "0.8.0",
-  "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log y diff.",
+  "version": "0.10.0",
+  "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log, diff y sync.",
   "keywords": [
     "shilo",
     "cli",
@@ -25,7 +25,8 @@
     "README.md"
   ],
   "scripts": {
-    "start": "node bin/shilo.js"
+    "start": "node bin/shilo.js",
+    "test": "node --test"
   },
   "engines": {
     "node": ">=18"

package/src/ShiloClient.js

@@ -791,6 +791,29 @@ class ShiloClient {
     };
   }
 
+  /**
+   * Destino e historial de deploys a Vercel (PLAN_DEPLOY_VERCEL). Devuelve
+   * `{ connected, can_manage, target, deployments, credentials }`. Un servidor
+   * sin deploys responde 404: se marca `notSupported`.
+   */
+  async getDeploys(projectId, credentials) {
+    const url = `${this.baseURL}/api/deploys/${encodeURIComponent(projectId)}`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials);
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudieron leer los deploys: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data, notSupported: res.status === 404 || res.status === 405 }
+      );
+    }
+    return {
+      connected: !!(data && data.connected),
+      can_manage: !!(data && data.can_manage),
+      target: (data && data.target) || null,
+      deployments: data && Array.isArray(data.deployments) ? data.deployments : [],
+      credentials: creds,
+    };
+  }
+
   /**
    * Propuestas (Etapa 3). Guardar es proponer: el cliente dice de qué versión
    * partió (`base`, el oid de la versión actual que vio) y qué cambió, y el
@@ -818,6 +841,9 @@ class ShiloClient {
     return {
       main: (data && data.main) || null,
       proposals: data && Array.isArray(data.proposals) ? data.proposals : [],
+      // Servidores anteriores no los mandan: quien llama tiene que tolerar null.
+      viewer: (data && data.viewer) || null,
+      project: (data && data.project) || null,
       credentials: creds,
     };
   }
@@ -836,11 +862,16 @@ class ShiloClient {
    * `[card: …]` del mensaje, que se queda porque es el formato de todo lo ya
    * guardado; la clave es la que se puede consultar.
    *
-   * Devuelve `{ applied, empty, proposal, conflicts, blockedBy, main, message,
-   * warnings, credentials }`. Los 200 y 202 son respuestas normales (aplicada /
+   * `chequeos` es el resultado de los chequeos del proyecto (MU-93,
+   * `checks.js`): la propuesta lo lleva y una fallida no se aplica sola.
+   *
+   * Devuelve `{ applied, empty, proposal, conflicts, blockedBy, lineas,
+   * chequeos, piezas, main, message, warnings, credentials }`; `lineas` son las rutas
+   * que el servidor combinó por líneas (MU-92) y `piezas`, las piezas USEE
+   * que dejarían de pasar el Nivel 1 (MU-94). Los 200 y 202 son respuestas normales (aplicada /
    * quedó abierta); cualquier otro estado es error.
    */
-  async propose(projectId, { base, title, summary, changes, agent, prompt, card }, credentials) {
+  async propose(projectId, { base, title, summary, changes, agent, prompt, card, chequeos }, credentials) {
     const url = `${this.baseURL}/api/projects/proposals`;
     const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
       method: 'POST',
@@ -853,6 +884,7 @@ class ShiloClient {
         ...(agent ? { agent } : {}),
         ...(prompt ? { prompt } : {}),
         ...(card ? { card } : {}),
+        ...(chequeos ? { chequeos } : {}),
       },
     });
     if (!res.ok && res.status !== 202) {
@@ -867,6 +899,9 @@ class ShiloClient {
       proposal: (data && data.proposal) || null,
       conflicts: data && Array.isArray(data.conflicts) ? data.conflicts : [],
       blockedBy: data && Array.isArray(data.blocked_by) ? data.blocked_by : [],
+      lineas: data && Array.isArray(data.lineas) ? data.lineas : [],
+      chequeos: (data && data.chequeos) || null,
+      piezas: data && Array.isArray(data.piezas) ? data.piezas : [],
       main: (data && data.main) || null,
       message: (data && data.message) || '',
       warnings: data && Array.isArray(data.warnings) ? data.warnings : [],
@@ -876,14 +911,16 @@ class ShiloClient {
 
   /**
    * Resuelve una propuesta abierta: `apply` (dueño) o `discard` (dueño o
-   * autor). Devuelve `{ applied, proposal, conflicts, main, credentials }`; con
+   * autor). `resolutions` ({ ruta: 'actual' | 'propuesta' | 'ambas' }) decide
+   * los archivos en conflicto al aplicar; `force` aplica aunque sus chequeos
+   * o sus piezas USEE hayan fallado (MU-93, MU-94). Devuelve `{ applied, proposal, conflicts, main, credentials }`; con
    * `apply` un 409 significa que sigue en conflicto y viene con los datos.
    */
-  async resolveProposal(projectId, id, action, credentials) {
+  async resolveProposal(projectId, id, action, credentials, { resolutions = null, force = false } = {}) {
     const url = `${this.baseURL}/api/projects/proposals`;
     const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
       method: 'POST',
-      body: { projectId, id, action },
+      body: { projectId, id, action, ...(resolutions ? { resolutions } : {}), ...(force ? { force: true } : {}) },
     });
     const stillOpen = action === 'apply' && res.status === 409 && data && data.proposal;
     if (!res.ok && !stillOpen) {
@@ -896,6 +933,8 @@ class ShiloClient {
       applied: !!(data && data.applied),
       proposal: (data && data.proposal) || null,
       conflicts: data && Array.isArray(data.conflicts) ? data.conflicts : [],
+      lineas: data && Array.isArray(data.lineas) ? data.lineas : [],
+      piezas: data && Array.isArray(data.piezas) ? data.piezas : [],
       main: (data && data.main) || null,
       message: (data && data.message) || '',
       credentials: creds,

package/src/checks.js

@@ -0,0 +1,57 @@
+/**
+ * Chequeos de propuesta (EP-S2, MU-93).
+ *
+ * Un proyecto declara en `shilo.config.json` los comandos que tienen que pasar
+ * antes de proponer (`"chequeos": ["npm test"]`). `shilo push` los corre en la
+ * carpeta, uno por uno y en orden, con la salida a la vista, y el resultado
+ * viaja con la propuesta: la web la muestra verificada o fallida, y aplicar una
+ * fallida exige forzar.
+ *
+ * Se corta en el primero que falla, como un hook de git: lo que viene después
+ * suele depender de lo anterior (instalar, compilar, probar) y correrlo sólo
+ * hace más largo el error. El resultado registra lo que se corrió.
+ *
+ * `run` se inyecta para probarlo sin lanzar procesos.
+ */
+
+'use strict';
+
+const childProcess = require('child_process');
+
+// Un chequeo colgado no puede dejar colgado el push: a los diez minutos se corta
+// y cuenta como fallido.
+const CHECK_TIMEOUT_MS = 10 * 60 * 1000;
+
+function spawnCheck(comando, dir) {
+  const r = childProcess.spawnSync(comando, {
+    cwd: dir,
+    shell: true,
+    stdio: 'inherit',
+    timeout: CHECK_TIMEOUT_MS,
+    windowsHide: true,
+  });
+  // Sin `status` = no llegó a terminar (no se pudo lanzar, o se cortó por tiempo).
+  return { codigo: typeof r.status === 'number' ? r.status : null };
+}
+
+/**
+ * @param {string} dir - la carpeta donde se corren
+ * @param {string[]} comandos
+ * @param {{ run?: Function, now?: Function, onStart?: Function }} [opts]
+ * @returns {{ resultado: 'ok'|'fallido', comandos: Array<{ comando, ok, codigo?, ms }> }}
+ */
+function runChecks(dir, comandos, { run = spawnCheck, now = Date.now, onStart = () => {} } = {}) {
+  const out = [];
+  for (const comando of comandos) {
+    onStart(comando, out.length + 1, comandos.length);
+    const t0 = now();
+    const { codigo } = run(comando, dir);
+    const entry = { comando, ok: codigo === 0, ms: Math.max(0, Math.round(now() - t0)) };
+    if (codigo !== null) entry.codigo = codigo;
+    out.push(entry);
+    if (!entry.ok) break;
+  }
+  return { resultado: out.every((c) => c.ok) ? 'ok' : 'fallido', comandos: out };
+}
+
+module.exports = { runChecks, CHECK_TIMEOUT_MS };

package/src/commands/deploys.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const { resolveContext } = require('../context');
+
+const DEFAULT_LIMIT = 10;
+
+const STATUS = {
+  queued: (s) => ui.c.dim(s),
+  running: (s) => ui.c.cyan(s),
+  uploading: (s) => ui.c.cyan(s),
+  building: (s) => ui.c.cyan(s),
+  ready: (s) => ui.c.green(s),
+  error: (s) => ui.c.red(s),
+  canceled: (s) => ui.c.dim(s),
+  superseded: (s) => ui.c.dim(s),
+};
+
+const AUTO = {
+  off: 'sólo manual',
+  preview: 'preview en cada guardado',
+  production: 'producción en cada guardado',
+};
+
+/**
+ * shilo deploys [-n <N>] [--project <uuid>] [--json]
+ *
+ * Destino e historial de deploys a Vercel del proyecto (PLAN_DEPLOY_VERCEL,
+ * Etapa 4.2). Sólo lectura. El servidor devuelve como mucho los últimos 20.
+ */
+async function deploys(args) {
+  const ctx = resolveContext({ ...args, _: [] });
+  if (!ctx.ok) return ctx.code;
+
+  const { projectId, baseURL, cfg, client, mgr } = ctx;
+
+  const limit = parseLimit(args.n || args.number);
+  if (limit === null) {
+    ui.error('El valor de -n debe ser un entero entre 1 y 20.');
+    return 1;
+  }
+
+  let info;
+  try {
+    info = await client.getDeploys(projectId, await mgr.valid());
+  } catch (e) {
+    ui.error(e.notSupported ? 'Este servidor de Shilo todavía no tiene deploys.' : e.message);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  const list = info.deployments.slice(0, limit);
+
+  if (args.json) {
+    console.log(JSON.stringify({ projectId, connected: info.connected, target: info.target, deployments: list }, null, 2));
+    return 0;
+  }
+
+  ui.info(`Deploys del proyecto — ${ui.c.cyan(baseURL)}`);
+  if (!info.target) {
+    ui.info('');
+    ui.info('Este proyecto no despliega a ningún lado. El owner lo configura en la');
+    ui.info('pestaña "Deploys" del proyecto en la web.');
+    return 0;
+  }
+
+  const t = info.target;
+  ui.info(`Vercel: ${ui.c.bold(t.vercel_project_name || t.vercel_project)} · ${AUTO[t.auto_target] || t.auto_target}`);
+  if (!info.connected) {
+    ui.warn('La conexión con Vercel no está activa: el owner tiene que volver a conectar.');
+  }
+  ui.info('');
+
+  if (list.length === 0) {
+    ui.info('Todavía no hubo deploys.');
+    return 0;
+  }
+
+  for (const d of list) {
+    const paint = STATUS[d.status] || ((s) => s);
+    const commit = d.commit_oid ? String(d.commit_oid).slice(0, 8) : '--------';
+    const target = d.target === 'production' ? ui.c.bold('prod   ') : 'preview';
+    const card = d.card ? ui.c.dim(` [card: ${d.card}]`) : '';
+    ui.info(`${paint(pad(d.status, 10))} ${target}  ${ui.c.yellow(commit)}  ${ui.c.dim(sync.formatDate(d.created_at))}${card}`);
+    if (d.url) ui.info(`    ${d.url}`);
+    if (d.error) ui.info(`    ${ui.c.red(d.error)}`);
+  }
+  return 0;
+}
+
+function pad(s, n) {
+  return String(s).padEnd(n);
+}
+
+function parseLimit(raw) {
+  if (raw === undefined || raw === null || raw === '') return DEFAULT_LIMIT;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > 20) return null;
+  return n;
+}
+
+module.exports = deploys;

package/src/commands/diff.js

@@ -126,7 +126,7 @@ async function diffAll({ dir, projectId, baseURL, cfg, client, mgr }) {
     config.persistCredsIfChanged(cfg, mgr.current);
   }
 
-  const cmp = sync.compareTrees(local.files, tree.files);
+  const cmp = sync.refineByHash(sync.compareTrees(local.files, tree.files), { dir, projectId, baseURL });
 
   // Un archivo ignorado localmente no es una diferencia que haya que resolver:
   // el push no lo sube y el pull no lo baja. Se nombra aparte, no como "sólo

package/src/commands/init.js

@@ -106,6 +106,14 @@ async function init(args) {
   const written = remote.write(dir, { projectId, baseURL });
   ui.success(`Carpeta atada al proyecto ${ui.c.bold(projectId)}.`);
   ui.info(ui.c.dim(`Remote guardado en ${written}`));
+  // Se lee siempre (ver walk.js), pero no decirlo hacía que la gente copiara
+  // a mano cada línea del .gitignore al .shiloignore.
+  if (fs.existsSync(path.join(dir, '.gitignore'))) {
+    ui.info(
+      ui.c.dim('Se respeta tu .gitignore: lo que git ignora tampoco se sube. ') +
+        ui.c.dim('.shiloignore es sólo para exclusiones extra.')
+    );
+  }
 
   // --push/--pull no implican confirmación: el usuario pidió *encadenar* el
   // comando, no saltearse su preflight. Sin --yes, push muestra el plan (y el