shilo-cli 0.6.0 → 0.8.0

package/src/args.js

@@ -10,14 +10,32 @@
  *   -m "msg"          -> alias corto (ver `aliases`)
  *   positionals       -> array de argumentos sueltos
  *
+ * Las claves de `multiple` acumulan en un array en vez de pisarse, y quedan
+ * SIEMPRE como array (aunque haya una sola aparición, o ninguna): así el
+ * consumidor no tiene que distinguir "uno" de "varios", que es justo donde se
+ * cuelan los bugs de `--only`.
+ *
  * Devuelve { _: [positionals...], ...flags }.
  */
-function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
+function parseArgs(argv, { booleans = [], aliases = {}, multiple = [] } = {}) {
   const out = { _: [] };
   const boolSet = new Set(booleans);
+  const multiSet = new Set(multiple);
 
   const canonical = (k) => aliases[k] || k;
 
+  const set = (key, value) => {
+    if (!multiSet.has(key)) {
+      out[key] = value;
+      return;
+    }
+    // `--only` sin valor (`--only --yes`) no es una lista de nada: se descarta
+    // en vez de meter un `true` que el consumidor tendría que filtrar.
+    if (value === true) return;
+    if (!Array.isArray(out[key])) out[key] = [];
+    out[key].push(value);
+  };
+
   for (let i = 0; i < argv.length; i++) {
     let token = argv[i];
 
@@ -37,17 +55,17 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
       }
       key = canonical(key);
       if (value !== undefined) {
-        out[key] = value;
+        set(key, value);
       } else if (boolSet.has(key)) {
-        out[key] = true;
+        set(key, true);
       } else {
         const next = argv[i + 1];
         // `-` a secas es un valor legítimo ("leer de stdin"), no otra bandera.
         if (next !== undefined && (next === '-' || !next.startsWith('-'))) {
-          out[key] = next;
+          set(key, next);
           i++;
         } else {
-          out[key] = true;
+          set(key, true);
         }
       }
       continue;
@@ -56,15 +74,15 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
     if (token.startsWith('-') && token.length > 1) {
       const key = canonical(token.slice(1));
       if (boolSet.has(key)) {
-        out[key] = true;
+        set(key, true);
       } else {
         const next = argv[i + 1];
         // `-` a secas es un valor legítimo ("leer de stdin"), no otra bandera.
         if (next !== undefined && (next === '-' || !next.startsWith('-'))) {
-          out[key] = next;
+          set(key, next);
           i++;
         } else {
-          out[key] = true;
+          set(key, true);
         }
       }
       continue;
@@ -73,6 +91,12 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
     out._.push(token);
   }
 
+  // Normalización: una clave `multiple` que no apareció igual llega como array
+  // vacío, para que el consumidor pueda hacer `.length` sin chequear antes.
+  for (const key of multiSet) {
+    if (!Array.isArray(out[key])) out[key] = [];
+  }
+
   return out;
 }
 

package/src/commands/diff.js

@@ -127,16 +127,32 @@ async function diffAll({ dir, projectId, baseURL, cfg, client, mgr }) {
   }
 
   const cmp = sync.compareTrees(local.files, tree.files);
-  const total = cmp.onlyLocal.length + cmp.onlyRemote.length + cmp.differing.length;
+
+  // 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
+  // remoto", que invita a un pull que igual no lo traería.
+  const isIgnoredPath = sync.makePathMatcher(dir);
+  const onlyRemote = cmp.onlyRemote.filter((i) => !isIgnoredPath(i.repoPath));
+  const ignoredRemote = cmp.onlyRemote.filter((i) => isIgnoredPath(i.repoPath));
+
+  const total = cmp.onlyLocal.length + onlyRemote.length + cmp.differing.length;
 
   ui.info('');
   if (total === 0) {
     ui.success('Sin diferencias de tamaño ni de archivos entre local y remoto.');
+    if (ignoredRemote.length > 0) {
+      ui.info(
+        ui.c.dim(`(${ignoredRemote.length} archivo(s) del remoto están ignorados localmente.)`)
+      );
+    }
     return 0;
   }
 
   for (const item of cmp.onlyLocal) ui.info(`  ${ui.c.green('+')} ${item.repoPath} ${ui.c.dim('(sólo local)')}`);
-  for (const item of cmp.onlyRemote) ui.info(`  ${ui.c.red('-')} ${item.repoPath} ${ui.c.dim('(sólo remoto)')}`);
+  for (const item of onlyRemote) ui.info(`  ${ui.c.red('-')} ${item.repoPath} ${ui.c.dim('(sólo remoto)')}`);
+  for (const item of ignoredRemote) {
+    ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(`${item.repoPath} (sólo remoto, ignorado localmente)`)}`);
+  }
   for (const item of cmp.differing) {
     const delta = item.local.size - item.remote.size;
     const sign = delta > 0 ? `+${delta}` : String(delta);

package/src/commands/export.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const path = require('path');
+const config = require('../config');
+const remote = require('../remote');
+const ui = require('../ui');
+const sync = require('../sync');
+const { ShiloClient } = require('../ShiloClient');
+const { DEFAULT_BASE_URL } = require('../context');
+const { exportarProyecto, leerMapa } = require('../exportgit');
+
+/**
+ * shilo export <carpeta> [--project <uuid>] [--base-url <url>] [--json]
+ *
+ * Escribe la historia del proyecto como un repositorio Git en `carpeta`, con
+ * `main` y `refs/notes/shilo`. La primera vez la carpeta tiene que estar vacía
+ * o no existir; después, repetir el comando sobre la misma carpeta trae sólo
+ * lo nuevo. No toca el proyecto: es de sólo lectura.
+ *
+ * El proyecto sale de `--project`, de la exportación anterior que haya en la
+ * carpeta, o del `.shilo.json` de la carpeta actual, en ese orden. Un proyecto
+ * público se exporta sin sesión.
+ */
+async function exportCmd(args) {
+  const destinoArg = typeof args._[0] === 'string' ? args._[0] : null;
+  if (!destinoArg) {
+    ui.error('Falta la carpeta de destino: shilo export <carpeta>.');
+    return 1;
+  }
+  const destino = path.resolve(destinoArg);
+  const asJson = !!args.json;
+
+  let previo = null;
+  let atada = null;
+  try {
+    previo = leerMapa(path.join(destino, '.git'));
+    atada = remote.read(process.cwd());
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+
+  const pedido = typeof args.project === 'string' && args.project.trim() ? args.project.trim() : null;
+  if (pedido && previo && previo.projectId !== pedido) {
+    ui.error(`${destino} ya tiene la exportación de otro proyecto (${previo.projectId}).`);
+    ui.info('Exportá a una carpeta nueva.');
+    return 1;
+  }
+  const projectId = pedido || (previo && previo.projectId) || (atada && atada.projectId) || null;
+  if (!projectId) {
+    ui.error('No sé qué proyecto exportar.');
+    ui.info('Pasá --project <uuid>, o corré el comando dentro de una carpeta atada con "shilo init".');
+    return 1;
+  }
+
+  const cfg = config.load() || {};
+  const baseURL = args['base-url'] || (previo && previo.baseURL) || (atada && atada.baseURL) || cfg.baseURL || DEFAULT_BASE_URL;
+  const client = new ShiloClient({
+    baseURL,
+    supabaseUrl: cfg.supabaseUrl || null,
+    supabaseAnonKey: cfg.supabaseAnonKey || null,
+  });
+
+  // Sin sesión se intenta igual: un proyecto público se exporta sin cuenta.
+  let creds = null;
+  if (cfg.credentials) {
+    try {
+      creds = await sync.makeCredsManager(client, cfg).valid();
+    } catch (e) {
+      ui.error(`La sesión guardada no sirve: ${e.message}`);
+      ui.info('Corré "shilo login" de nuevo.');
+      return 1;
+    }
+  }
+
+  let progreso = null;
+  if (!asJson) {
+    ui.info(`${previo ? 'Actualizando la exportación' : 'Exportando'} de ${ui.c.bold(projectId)} en ${ui.c.bold(destino)}`);
+    ui.info(ui.c.dim(`Servidor: ${baseURL}`));
+  }
+
+  let informe;
+  try {
+    informe = await exportarProyecto({
+      client,
+      projectId,
+      creds,
+      destino,
+      baseURL,
+      onEtapa: (nombre, detalle) => {
+        if (asJson) return;
+        if (nombre === 'archivos' && detalle > 0) {
+          ui.info(`Bajando ${detalle} archivo(s)…`);
+          progreso = ui.progress(detalle, 'archivos');
+        }
+      },
+      onProgreso: (hechos) => { if (progreso) progreso.update(hechos); },
+    });
+  } catch (e) {
+    if (progreso) progreso.clear();
+    return explicarError(e, { destino, projectId, conSesion: Boolean(creds), asJson });
+  } finally {
+    if (creds) config.persistCredsIfChanged(cfg, creds);
+  }
+  if (progreso) progreso.clear();
+  if (informe.credentials) config.persistCredsIfChanged(cfg, informe.credentials);
+
+  if (asJson) {
+    const { credentials, ...resto } = informe;
+    console.log(JSON.stringify({ projectId, ...resto }, null, 2));
+    return 0;
+  }
+
+  mostrarInforme(informe);
+  return 0;
+}
+
+function mostrarInforme(inf) {
+  ui.info('');
+  if (inf.incremental && inf.mainAntes === inf.main) {
+    ui.success('Ya estaba al día: no hay puntos de guardado nuevos.');
+  } else if (inf.incremental) {
+    ui.success(`${inf.nuevos} punto(s) de guardado nuevo(s); ${inf.commits} en total.`);
+  } else {
+    ui.success(`${inf.commits} punto(s) de guardado exportado(s).`);
+  }
+  ui.info(`  main           ${ui.c.yellow(inf.main.slice(0, 12))}`);
+  if (inf.notas) ui.info(`  procedencia    ${ui.c.yellow(inf.notas.slice(0, 12))} ${ui.c.dim('(refs/notes/shilo)')}`);
+  ui.info(ui.c.dim(`  ${inf.archivos} archivo(s) y ${inf.carpetas} carpeta(s) bajados, ${formatoBytes(inf.bytes)}.`));
+
+  if (inf.vacias.length > 0) {
+    ui.info('');
+    ui.warn(`Git no guarda carpetas vacías; quedaron afuera ${inf.vacias.length}:`);
+    for (const r of inf.vacias.slice(0, 20)) ui.info(`  ${r}/`);
+    if (inf.vacias.length > 20) ui.info(ui.c.dim(`  … y ${inf.vacias.length - 20} más.`));
+  }
+
+  if (!inf.carpetaActualizada) {
+    ui.info('');
+    ui.info(ui.c.dim('La carpeta no está en main: se movió la rama pero no se tocaron tus archivos.'));
+  }
+
+  ui.info('');
+  ui.info('Para subirlo a otro servidor Git:');
+  ui.info(ui.c.cyan(`  git -C "${inf.destino}" push <remoto> main`));
+  if (inf.notas) {
+    // La ref de notas se rehace entera en cada exportación (no tiene padre),
+    // así que un push normal la rechaza a partir de la segunda: va con `+`.
+    ui.info(ui.c.cyan(`  git -C "${inf.destino}" push <remoto> +refs/notes/shilo`));
+    if (inf.notasReemplazadas) {
+      ui.info(ui.c.dim('  La procedencia se reemplazó entera; por eso el + en el push.'));
+    }
+  }
+}
+
+function explicarError(e, { destino, projectId, conSesion, asJson }) {
+  const code = e && e.code;
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: false, code: code || null, status: (e && e.status) || null, message: e.message, path: e.path || null,
+    }, null, 2));
+    return 1;
+  }
+
+  ui.error(e.message);
+  switch (code) {
+    case 'SIN_GIT':
+      ui.info('Instalá Git (https://git-scm.com) y volvé a correr el comando.');
+      break;
+    case 'DESTINO_OCUPADO':
+      ui.info('La primera exportación va a una carpeta vacía o que no existe.');
+      break;
+    case 'OTRO_PROYECTO':
+      ui.info('Exportá a una carpeta nueva.');
+      break;
+    case 'MAIN_AJENA':
+      ui.info('Hay puntos de guardado en main que no vienen de Shilo. Llevalos a otra rama');
+      ui.info('(git branch <nombre> main) y devolvé main a lo exportado, o exportá a una carpeta nueva.');
+      break;
+    case 'CAMBIOS_LOCALES':
+      ui.info('Guardalos o descartalos (git stash) antes de actualizar la exportación.');
+      break;
+    case 'MAPA_ILEGIBLE':
+    case 'REPO_INCOMPLETO':
+      ui.info('La exportación anterior está dañada. Exportá a una carpeta nueva.');
+      break;
+    case 'SIN_IDENTIDADES':
+      ui.info('Hay que aplicar la migración 018 en el servidor antes de exportar.');
+      break;
+    case 'PROYECTO_VACIO':
+      ui.info('Guardá una versión primero.');
+      break;
+    case 'NOMBRE_INVALIDO':
+      ui.info(`Git no acepta «${e.path || e.name}». Renombralo en Shilo y exportá de nuevo.`);
+      break;
+    case 'SHA1_MOVIDO':
+      ui.info('Lo ya exportado daría otro resultado: es un error de Shilo, no de tu carpeta. Avisanos.');
+      break;
+    case 'GRAFO_INCOMPLETO':
+    case 'BLOB_CORRUPTO':
+    case 'ARBOL_CORRUPTO':
+    case 'FALTA_OBJETO':
+      ui.info('A la historia del proyecto le falta algo en el servidor. No se escribió ninguna rama.');
+      break;
+    default:
+      if (e && e.status === 404) {
+        ui.info(conSesion
+          ? `El proyecto ${projectId} no existe o no tenés acceso.`
+          : 'Si el proyecto es privado, iniciá sesión con "shilo login".');
+      } else if (e && e.status === 401) {
+        ui.info('Corré "shilo login" de nuevo.');
+      }
+  }
+  if (code && code !== 'DESTINO_OCUPADO' && code !== 'SIN_GIT' && code !== 'OTRO_PROYECTO') {
+    ui.info(ui.c.dim(`Carpeta: ${destino}`));
+  }
+  return 1;
+}
+
+function formatoBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+module.exports = exportCmd;

package/src/commands/log.js

@@ -4,6 +4,7 @@ const config = require('../config');
 const ui = require('../ui');
 const sync = require('../sync');
 const { resolveContext } = require('../context');
+const { marcaDeRevision } = require('./review');
 
 const DEFAULT_LIMIT = 20;
 
@@ -90,6 +91,7 @@ async function log(args) {
             message: c.message,
             author: sync.describeAuthor(c.users),
             date: c.created_at,
+            reviews: Array.isArray(c.reviews) ? c.reviews : [],
             files: (c.files || []).map((cf) => ({
               name: cf.files ? cf.files.name : null,
               action: cf.action,
@@ -122,6 +124,8 @@ async function log(args) {
     const hash = commit.hash ? String(commit.hash).slice(0, 8) : '(sin hash)';
     ui.info(`${ui.c.yellow(hash)}  ${ui.c.bold(sync.describeAuthor(commit.users))}  ${ui.c.dim(sync.formatDate(commit.created_at))}`);
     ui.info(`    ${commit.message}`);
+    const marca = marcaDeRevision(commit.reviews);
+    if (marca) ui.info(`    ${ui.c.dim('revisión:')} ${marca}`);
     if (showFiles && Array.isArray(commit.files) && commit.files.length > 0) {
       const shown = repoPath
         ? commit.files.filter((cf) => cf.files && cf.files.id === targetId)

package/src/commands/pull.js

@@ -40,6 +40,38 @@ function readLocalBytes(absPath) {
   }
 }
 
+/**
+ * Carpeta de respaldo de esta corrida: `.shilo/respaldo/<ISO>/`.
+ *
+ * Va adentro de `.shilo/` —que está en DEFAULT_IGNORES— y no como un
+ * `<archivo>.local` al lado: un hermano se vuelve un archivo más del árbol y el
+ * push siguiente lo sube, o sea que cambiaríamos "perder trabajo" por "publicar
+ * tu versión en conflicto". Al ir por timestamp, dos pulls seguidos no se pisan.
+ *
+ * Los `:` del ISO no son válidos en nombres de archivo de Windows.
+ */
+function backupDirFor(dir, stamp) {
+  return path.join(dir, '.shilo', 'respaldo', stamp.replace(/:/g, '-'));
+}
+
+/**
+ * Copia la versión local de `repoPath` al respaldo antes de pisarla. Devuelve
+ * true si quedó copiada. Es best-effort: si falla, el pull sigue —avisando—
+ * porque abortar a mitad del pool dejaría la carpeta peor que como estaba.
+ */
+function backupLocal(baseDir, absPath, repoPath) {
+  try {
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) return false;
+    const target = path.join(baseDir, ...repoPath.split('/'));
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(absPath, target);
+    return true;
+  } catch (e) {
+    ui.warn(`no se pudo respaldar ${ui.c.dim(repoPath)} — ${e.message}`);
+    return false;
+  }
+}
+
 /**
  * shilo pull [carpeta] [--project <uuid>] [--base-url <url>] [--dry-run] [--yes] [--force]
  *
@@ -55,7 +87,7 @@ async function pull(args) {
   const ctx = resolveContext(args, { requireDir: false });
   if (!ctx.ok) return ctx.code;
 
-  const { dir, projectId, baseURL, cfg, client, mgr } = ctx;
+  const { dir, projectId, baseURL, cfg, client, mgr, savedRemote } = ctx;
 
   // La carpeta destino puede no existir todavía: la creamos al escribir. Si
   // existe pero es un archivo, es un error del usuario.
@@ -68,6 +100,19 @@ async function pull(args) {
 
   ui.info(`Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — recorriendo árbol ...`);
 
+  // La versión actual ANTES de recorrer el árbol: si alguien guarda en el
+  // medio, la base que anotamos queda más vieja que los archivos que bajamos,
+  // y eso sólo puede hacer que el push siguiente vea un conflicto de más, nunca
+  // uno de menos. Un servidor sin la Etapa 3 no la tiene; se sigue sin base.
+  let main = null;
+  try {
+    const creds = await mgr.valid();
+    const listed = await client.listProposals(projectId, creds, { state: 'abierta' });
+    main = listed.main;
+  } catch (e) {
+    if (!e.notSupported) ui.warn(`No se pudo leer la versión actual: ${e.message}`);
+  }
+
   let tree;
   try {
     tree = await sync.walkRemote(client, projectId, mgr);
@@ -88,14 +133,27 @@ async function pull(args) {
   //    devuelve una URL firmada en vez de contenido, y se bajan como bytes. Lo
   //    que se saltaba antes no era una limitación del formato sino del camino:
   //    el contenido viajaba como texto y un PNG volvía mutilado.
+  //
+  //    Lo ignorado localmente tampoco se baja: si `.env.*` está en el ignore,
+  //    que alguien haya subido un `.env.ejemplo` desde otra máquina no es razón
+  //    para que aparezca acá. Además arregla el conteo: antes entraban en
+  //    "nuevos" (walkLocal no los ve) y después se descartaban al descargar.
+  const includeIgnored = !!args['include-ignored'];
+  const isIgnoredPath = sync.makePathMatcher(dir);
+
   const candidates = [];
   const unsafe = [];
+  const ignoredRemote = [];
   for (const f of tree.files) {
     const safe = safeTarget(dir, f.repoPath);
     if (!safe.ok) {
       unsafe.push({ repoPath: f.repoPath, reason: safe.reason });
       continue;
     }
+    if (!includeIgnored && isIgnoredPath(f.repoPath)) {
+      ignoredRemote.push(f.repoPath);
+      continue;
+    }
     candidates.push({ ...f, target: safe.target, binary: !sync.isTextMime(f.mime_type) });
   }
 
@@ -128,6 +186,9 @@ async function pull(args) {
       `  ${ui.c.dim('posiblemente iguales:')} ${maybeSame.length}\n` +
       `  ${ui.c.dim('sólo locales:')}     ${onlyLocal.length}   ${ui.c.dim('(el pull no los toca)')}` +
       (binaryCount ? `\n  ${ui.c.dim('binarios:')}        ${binaryCount}` : '') +
+      (ignoredRemote.length
+        ? `\n  ${ui.c.dim('ignorados:')}       ${ignoredRemote.length}   ${ui.c.dim('(no se bajan)')}`
+        : '') +
       (unsafe.length ? `\n  ${ui.c.red('inseguros:')}       ${unsafe.length}` : '')
   );
   ui.info('');
@@ -144,6 +205,9 @@ async function pull(args) {
       );
     }
     for (const f of onlyLocal) ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(`${f.repoPath} (sólo local, se conserva)`)}`);
+    for (const p of ignoredRemote) {
+      ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(`${p} (ignorado localmente, no se baja)`)}`);
+    }
     ui.info('');
     if (conflicting.length > 0) {
       ui.warn(`${conflicting.length} archivo(s) locales se sobrescribirían: hace falta --force.`);
@@ -191,9 +255,17 @@ async function pull(args) {
 
   // 6) Descargar y escribir, con pool. Recién acá se sabe si un archivo del
   //    mismo tamaño era realmente idéntico: si lo era, no se reescribe.
+  //    Antes de pisar un archivo que difería del remoto (sólo pasa con --force)
+  //    se guarda la versión local bajo `.shilo/respaldo/<ISO>/`: recuperarse de
+  //    una divergencia dejaba de depender de haber copiado a mano antes.
+  const conflictPaths = new Set(conflicting.map((f) => f.repoPath));
+  const backupStamp = new Date().toISOString();
+  const backupDir = backupDirFor(dir, backupStamp);
+
   const written = [];
   const unchanged = [];
   const failed = [];
+  const backedUp = [];
   const outcomes = await sync.runPool(toDownload, CONCURRENCY, async (f) => {
     const creds = await mgr.valid();
     const read = await client.readFile(projectId, f.repoPath, creds);
@@ -209,9 +281,13 @@ async function pull(args) {
         return { repoPath: f.repoPath, skipped: true };
       }
 
+      const saved = conflictPaths.has(f.repoPath)
+        ? backupLocal(backupDir, f.target, f.repoPath)
+        : false;
+
       fs.mkdirSync(path.dirname(f.target), { recursive: true });
       fs.writeFileSync(f.target, bytes);
-      return { repoPath: f.repoPath, skipped: false };
+      return { repoPath: f.repoPath, skipped: false, backedUp: saved };
     }
 
     const content = read.file && read.file.content != null ? read.file.content : '';
@@ -221,9 +297,13 @@ async function pull(args) {
       return { repoPath: f.repoPath, skipped: true };
     }
 
+    const saved = conflictPaths.has(f.repoPath)
+      ? backupLocal(backupDir, f.target, f.repoPath)
+      : false;
+
     fs.mkdirSync(path.dirname(f.target), { recursive: true });
     fs.writeFileSync(f.target, content, 'utf8');
-    return { repoPath: f.repoPath, skipped: false };
+    return { repoPath: f.repoPath, skipped: false, backedUp: saved };
   });
 
   for (const res of outcomes) {
@@ -234,6 +314,7 @@ async function pull(args) {
       unchanged.push(res.repoPath);
     } else {
       written.push(res.repoPath);
+      if (res.backedUp) backedUp.push(res.repoPath);
       ui.success(`${ui.c.green('↓')} ${res.repoPath}`);
     }
   }
@@ -245,9 +326,12 @@ async function pull(args) {
   const complete = failed.length === 0 && (args.force || conflicting.length === 0);
   try {
     if (complete) {
-      remote.write(dir, { projectId, baseURL, lastSync: new Date().toISOString() });
+      remote.write(dir, { projectId, baseURL, lastSync: new Date().toISOString(), base: main });
     } else if (written.length > 0) {
-      remote.write(dir, { projectId, baseURL });
+      // Carpeta a medias: se conserva la base anterior. Lo que sí se bajó ya
+      // coincide con la versión actual, así que en el próximo push no cuenta
+      // como cambio propio.
+      remote.write(dir, { projectId, baseURL, base: (savedRemote && savedRemote.base) || null });
     }
   } catch (e) {
     ui.warn(`No se pudo escribir ${remote.REMOTE_FILENAME}: ${e.message}`);
@@ -255,6 +339,22 @@ async function pull(args) {
 
   // 8) Resumen.
   ui.info('');
+  if (backedUp.length > 0) {
+    ui.info(
+      `${backedUp.length} versión(es) local(es) sobrescrita(s) quedaron respaldadas en ` +
+        ui.c.cyan(path.relative(dir, backupDir).split(path.sep).join('/'))
+    );
+    ui.info(ui.c.dim('(está dentro de .shilo/, así que no se sube ni aparece en el status.)'));
+    ui.info('');
+  }
+  if (ignoredRemote.length > 0) {
+    ui.info(
+      ui.c.dim(
+        `${ignoredRemote.length} archivo(s) del remoto están ignorados localmente y no se bajaron ` +
+          `(--include-ignored para bajarlos igual).`
+      )
+    );
+  }
   const tail = unchanged.length ? ` (${unchanged.length} ya estaban al día)` : '';
   if (failed.length === 0) {
     ui.success(`Pull completo: ${written.length} archivo(s) actualizados en "${dir}"${tail}.`);