shilo-cli 0.2.0 → 0.3.0

package/src/commands/pull.js

@@ -0,0 +1,239 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const config = require('../config');
+const remote = require('../remote');
+const prompt = require('../prompt');
+const ui = require('../ui');
+const sync = require('../sync');
+const { validatePath } = require('../textguard');
+const { resolveContext } = require('../context');
+
+const CONCURRENCY = sync.CONCURRENCY;
+
+/**
+ * Resuelve la ruta absoluta de escritura para un `repoPath`, blindando contra
+ * path traversal. Valida cada segmento con las mismas reglas del backend y
+ * exige que el destino final quede dentro de `destDir`.
+ * Devuelve `{ ok: true, target }` o `{ ok: false, reason }`.
+ */
+function safeTarget(destDir, repoPath) {
+  const check = validatePath(repoPath);
+  if (!check.ok) return { ok: false, reason: check.reason };
+
+  const target = path.resolve(destDir, repoPath);
+  const rel = path.relative(destDir, target);
+  if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) {
+    return { ok: false, reason: 'la ruta escaparía de la carpeta destino' };
+  }
+  return { ok: true, target };
+}
+
+/**
+ * shilo pull [carpeta] [--project <uuid>] [--base-url <url>] [--dry-run] [--yes] [--force]
+ *
+ * Baja un proyecto de Shilo a una carpeta local y deja `.shilo.json` listo para
+ * un `push` posterior.
+ *
+ * Seguridad ante trabajo local sin guardar: el pull NO pisa un archivo local que
+ * difiera del remoto salvo con `--force`. Los archivos que sólo existen en el
+ * remoto, y los que ya coinciden byte a byte, se resuelven solos. Un archivo que
+ * sólo existe localmente nunca se toca (el pull no borra).
+ */
+async function pull(args) {
+  const ctx = resolveContext(args, { requireDir: false });
+  if (!ctx.ok) return ctx.code;
+
+  const { dir, projectId, baseURL, cfg, client, mgr } = ctx;
+
+  // La carpeta destino puede no existir todavía: la creamos al escribir. Si
+  // existe pero es un archivo, es un error del usuario.
+  if (fs.existsSync(dir) && !fs.statSync(dir).isDirectory()) {
+    ui.error(`No es una carpeta válida: ${dir}`);
+    return 1;
+  }
+
+  const dryRun = !!args['dry-run'];
+
+  ui.info(`Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — recorriendo árbol ...`);
+
+  let tree;
+  try {
+    tree = await sync.walkRemote(client, projectId, mgr);
+  } catch (e) {
+    ui.error(`No se pudo recorrer el proyecto: ${e.message}`);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  for (const err of tree.errors) {
+    ui.warn(`no se pudo listar ${ui.c.dim(err.folderPath || '(raíz)')} — ${err.reason}`);
+  }
+
+  // 1) Separar texto (descargable) de lo que no se puede bajar sin corromper.
+  const candidates = [];
+  const skippedBinary = [];
+  const unsafe = [];
+  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 (!sync.isTextMime(f.mime_type)) {
+      skippedBinary.push({ repoPath: f.repoPath, reason: `mime no textual (${f.mime_type})` });
+      continue;
+    }
+    candidates.push({ ...f, target: safe.target });
+  }
+
+  for (const u of unsafe) ui.warn(`saltado ${ui.c.dim(u.repoPath)} — ${u.reason}`);
+  for (const s of skippedBinary) ui.warn(`saltado ${ui.c.dim(s.repoPath)} — ${s.reason}`);
+
+  // 2) Clasificar contra lo que hay en disco, sin bajar nada todavía.
+  //    `maybeSame` (mismo tamaño) se confirma recién al descargar el contenido.
+  const local = sync.walkLocal(dir);
+  const localByPath = new Map(local.files.map((f) => [f.repoPath, f]));
+
+  const newFiles = [];    // sólo en el remoto: bajar sin riesgo
+  const maybeSame = [];   // existe local con el mismo tamaño
+  const conflicting = []; // existe local con distinto tamaño: pisaría trabajo
+  for (const f of candidates) {
+    const localFile = localByPath.get(f.repoPath);
+    if (!localFile) newFiles.push(f);
+    else if (typeof f.size === 'number' && f.size !== localFile.size) conflicting.push(f);
+    else maybeSame.push(f);
+  }
+
+  const remotePaths = new Set(candidates.map((f) => f.repoPath));
+  const onlyLocal = local.files.filter((f) => !remotePaths.has(f.repoPath));
+
+  ui.info('');
+  ui.info(
+    `  ${ui.c.green('nuevos:')}          ${newFiles.length}\n` +
+      `  ${ui.c.yellow('en conflicto:')}    ${conflicting.length}   ${ui.c.dim('(difieren en tamaño del local)')}\n` +
+      `  ${ui.c.dim('posiblemente iguales:')} ${maybeSame.length}\n` +
+      `  ${ui.c.dim('sólo locales:')}     ${onlyLocal.length}   ${ui.c.dim('(el pull no los toca)')}` +
+      (skippedBinary.length ? `\n  ${ui.c.dim('binarios saltados:')} ${skippedBinary.length}` : '') +
+      (unsafe.length ? `\n  ${ui.c.red('inseguros:')}       ${unsafe.length}` : '')
+  );
+  ui.info('');
+
+  // 3) --dry-run: mostrar el plan contra el estado local y salir sin tocar disco.
+  if (dryRun) {
+    for (const f of newFiles) ui.info(`  ${ui.c.green('↓')} ${f.repoPath} ${ui.c.dim('(nuevo)')}`);
+    for (const f of conflicting) {
+      const localFile = localByPath.get(f.repoPath);
+      const delta = f.size - localFile.size;
+      ui.info(
+        `  ${ui.c.yellow('~')} ${f.repoPath} ` +
+          ui.c.dim(`(sobrescribe tu versión local, ${delta > 0 ? '+' : ''}${delta} bytes)`)
+      );
+    }
+    for (const f of onlyLocal) ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(`${f.repoPath} (sólo local, se conserva)`)}`);
+    ui.info('');
+    if (conflicting.length > 0) {
+      ui.warn(`${conflicting.length} archivo(s) locales se sobrescribirían: hace falta --force.`);
+      ui.info(ui.c.dim('Mirá "shilo diff <archivo>" antes de bajarlos.'));
+    }
+    ui.info(
+      ui.c.dim(
+        '(--dry-run: no se bajó nada. Los "posiblemente iguales" se confirman al descargar.)'
+      )
+    );
+    return 0;
+  }
+
+  // 4) Sin --force, los conflictos quedan afuera en vez de abortar todo el pull:
+  //    lo nuevo se baja igual y el usuario decide qué hacer con el resto.
+  let toDownload = [...newFiles, ...maybeSame];
+  if (conflicting.length > 0) {
+    if (args.force) {
+      toDownload = toDownload.concat(conflicting);
+    } else {
+      ui.warn(`${conflicting.length} archivo(s) difieren de tu copia local y NO se van a bajar:`);
+      for (const f of conflicting) ui.info(`  ${ui.c.yellow('~')} ${f.repoPath}`);
+      ui.info(ui.c.dim('Usá --force para sobrescribirlos, o "shilo diff <archivo>" para comparar.'));
+      ui.info('');
+    }
+  }
+
+  if (toDownload.length === 0) {
+    ui.info('No hay archivos para bajar.');
+    return conflicting.length > 0 && !args.force ? 1 : 0;
+  }
+
+  // 5) Confirmar (salvo --yes).
+  if (!args.yes) {
+    const overwrites = toDownload.filter((f) => fs.existsSync(f.target)).length;
+    const label = overwrites
+      ? `¿Bajar ${toDownload.length} archivo(s) a "${dir}" (${overwrites} ya existen)?`
+      : `¿Bajar ${toDownload.length} archivo(s) a "${dir}"?`;
+    const ok = await prompt.confirm(label, true);
+    if (!ok) {
+      ui.info('Cancelado.');
+      return 0;
+    }
+  }
+
+  // 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.
+  const written = [];
+  const unchanged = [];
+  const failed = [];
+  const outcomes = await sync.runPool(toDownload, CONCURRENCY, async (f) => {
+    const creds = await mgr.valid();
+    const read = await client.readFile(projectId, f.repoPath, creds);
+    const content = read.file && read.file.content != null ? read.file.content : '';
+
+    const current = sync.readLocalText(f.target);
+    if (current !== null && current === content) {
+      return { repoPath: f.repoPath, skipped: true };
+    }
+
+    fs.mkdirSync(path.dirname(f.target), { recursive: true });
+    fs.writeFileSync(f.target, content, 'utf8');
+    return { repoPath: f.repoPath, skipped: false };
+  });
+
+  for (const res of outcomes) {
+    if (res && res.__error) {
+      failed.push({ repoPath: res.item.repoPath, reason: res.__error });
+      ui.error(`${res.item.repoPath} — ${res.__error}`);
+    } else if (res.skipped) {
+      unchanged.push(res.repoPath);
+    } else {
+      written.push(res.repoPath);
+      ui.success(`${ui.c.green('↓')} ${res.repoPath}`);
+    }
+  }
+
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  // 7) Binding + marca de sincronización para el `status` siguiente. Sólo si el
+  //    pull cubrió todo: con conflictos pendientes la carpeta NO quedó alineada.
+  const complete = failed.length === 0 && (args.force || conflicting.length === 0);
+  try {
+    if (complete) {
+      remote.write(dir, { projectId, baseURL, lastSync: new Date().toISOString() });
+    } else if (written.length > 0) {
+      remote.write(dir, { projectId, baseURL });
+    }
+  } catch (e) {
+    ui.warn(`No se pudo escribir ${remote.REMOTE_FILENAME}: ${e.message}`);
+  }
+
+  // 8) Resumen.
+  ui.info('');
+  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}.`);
+    return conflicting.length > 0 && !args.force ? 1 : 0;
+  }
+  ui.warn(`Pull con problemas: ${failed.length} archivo(s) fallaron, ${written.length} bajados${tail}.`);
+  return 1;
+}
+
+module.exports = pull;

package/src/commands/push.js

@@ -6,6 +6,7 @@ const config = require('../config');
 const remote = require('../remote');
 const prompt = require('../prompt');
 const ui = require('../ui');
+const sync = require('../sync');
 const { walk } = require('../walk');
 const { classifyContent } = require('../textguard');
 const { ShiloClient } = require('../ShiloClient');
@@ -69,6 +70,12 @@ async function push(args) {
   const dryRun = !!args['dry-run'];
   const message =
     typeof args.message === 'string' && args.message.trim() ? args.message.trim() : null;
+  const card = typeof args.card === 'string' && args.card.trim() ? args.card.trim() : null;
+
+  if (card && card.length > 100) {
+    ui.error('El id de tarjeta (--card) no puede superar 100 caracteres.');
+    return 1;
+  }
 
   // 3) Recorrer la carpeta.
   const { files, skipped, ignored } = walk(dir);
@@ -166,6 +173,32 @@ async function push(args) {
 
   config.persistCredsIfChanged(cfg, creds);
 
+  // 5b) Atribución: para los archivos que vamos a pisar, quién los tocó último.
+  //     Es lo que distingue "esto lo subí yo antes" de "esto lo va a perder un
+  //     compañero". Best-effort: si el historial no se puede leer, seguimos.
+  let attribution = { index: new Map() };
+  const myId = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
+  if (plan.modified.length > 0) {
+    const mgr = sync.makeCredsManager(client, cfg);
+    attribution = await sync.buildAuthorIndex(client, projectId, mgr, { commits: 50 });
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  /** Etiqueta " — última edición de X, fecha" para un archivo del plan. */
+  const authorNote = (u) => {
+    const meta = u.remote && attribution.index.get(u.remote.id);
+    if (!meta) return '';
+    const mine = myId && meta.authorId && meta.authorId === myId;
+    const who = mine ? ui.c.dim('vos') : ui.c.bold(meta.author);
+    return ui.c.dim(' — última edición de ') + who + ui.c.dim(`, ${sync.formatDate(meta.date)}`);
+  };
+
+  /** ¿El último que tocó este archivo fue otra persona? */
+  const touchedByOthers = plan.modified.filter((u) => {
+    const meta = u.remote && attribution.index.get(u.remote.id);
+    return meta && meta.authorId && myId && meta.authorId !== myId;
+  });
+
   // 6) Reporte del plan.
   ui.info('');
   ui.info(`  ${ui.c.green('nuevos:')}       ${plan.added.length}`);
@@ -188,14 +221,38 @@ async function push(args) {
 
   if (dryRun) {
     for (const u of plan.added) ui.info(`  ${ui.c.green('+')} ${u.relPath}`);
-    for (const u of plan.modified) ui.info(`  ${ui.c.yellow('~')} ${u.relPath}`);
+    for (const u of plan.modified) ui.info(`  ${ui.c.yellow('~')} ${u.relPath}${authorNote(u)}`);
     for (const f of plan.failed) ui.info(`  ${ui.c.red('!')} ${f.relPath} — ${f.reason}`);
     ui.info('');
+    if (!myId && plan.modified.length > 0 && attribution.index.size > 0) {
+      ui.info(
+        ui.c.dim(
+          '(con token de acceso personal no sabemos tu id de usuario: ' +
+            'el autor se muestra, pero no se marca cuál sos vos)'
+        )
+      );
+      ui.info('');
+    }
+    if (touchedByOthers.length > 0) {
+      ui.warn(
+        `${touchedByOthers.length} de esos archivos los editó otra persona: ` +
+          `este push pisaría su versión.`
+      );
+      ui.info(ui.c.dim('Revisalos con "shilo diff <archivo>" o traelos con "shilo pull".'));
+      ui.info('');
+    }
     ui.info(ui.c.dim('(--dry-run: no se subió nada)'));
     return plan.failed.length ? 1 : 0;
   }
 
-  // 7) Confirmar (salvo --yes).
+  // 7) Confirmar (salvo --yes). Si vamos a pisar trabajo ajeno, lo decimos
+  //    antes de preguntar: es el caso que motivó todo este flujo.
+  if (touchedByOthers.length > 0) {
+    ui.warn(`Vas a pisar ${touchedByOthers.length} archivo(s) editado(s) por otra persona:`);
+    for (const u of touchedByOthers) ui.info(`  ${ui.c.red('!')} ${u.relPath}${authorNote(u)}`);
+    ui.info('');
+  }
+
   if (!args.yes) {
     const ok = await prompt.confirm(`¿Subir ${toWrite} archivo(s) al proyecto?`, true);
     if (!ok) {
@@ -269,7 +326,7 @@ async function push(args) {
     for (let i = 0; i < total; i += COMMIT_BATCH) {
       const batch = changes.slice(i, i + COMMIT_BATCH);
       const partNo = Math.floor(i / COMMIT_BATCH) + 1;
-      const msg = buildMessage(message, batch.length, total, partNo, nBatches);
+      const msg = buildMessage(message, batch.length, total, partNo, nBatches, card);
       try {
         const result = await client.createCommit(projectId, msg, batch, creds);
         creds = result.credentials;
@@ -284,7 +341,13 @@ async function push(args) {
 
   config.persistCredsIfChanged(cfg, creds);
 
-  // 10) Resumen final.
+  // 10) Anotar la sincronización: `status` la usa después para saber qué del
+  //     remoto es posterior a lo último que subimos.
+  if (failedWrites.length === 0) {
+    remote.touchSync(dir, { projectId, baseURL });
+  }
+
+  // 11) Resumen final.
   ui.info('');
   const nCommits = Math.ceil(changes.length / COMMIT_BATCH);
   if (failedWrites.length === 0) {
@@ -297,10 +360,21 @@ async function push(args) {
   return 1;
 }
 
-function buildMessage(userMsg, batchCount, total, partNo, nBatches) {
-  const base = userMsg || `shilo push: ${total} archivo(s)`;
-  if (nBatches > 1) return `${base} (${partNo}/${nBatches})`;
-  return base;
+/**
+ * Arma el mensaje del commit. Si vino `--card`, se agrega como trailer
+ * `[card: <id>]` al final: queda visible en el historial y es fácil de grepear
+ * para cruzar un cambio con la tarjeta que lo pidió (Metrónomo u otro tablero).
+ * El backend corta en 500 caracteres, así que recortamos el mensaje del usuario
+ * antes que el trailer.
+ */
+function buildMessage(userMsg, batchCount, total, partNo, nBatches, card) {
+  let base = userMsg || `shilo push: ${total} archivo(s)`;
+  if (nBatches > 1) base = `${base} (${partNo}/${nBatches})`;
+  if (!card) return base.slice(0, 500);
+
+  const trailer = ` [card: ${card}]`;
+  const room = 500 - trailer.length;
+  return `${base.slice(0, room)}${trailer}`;
 }
 
 module.exports = push;

package/src/commands/status.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const remote = require('../remote');
+const { resolveContext } = require('../context');
+
+/**
+ * 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:
+ *
+ *   - ¿el remoto tiene cambios que no tengo? (y de quién son)
+ *   - ¿tengo cambios locales sin subir?
+ *
+ * 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`.
+ */
+async function status(args) {
+  const ctx = resolveContext(args);
+  if (!ctx.ok) return ctx.code;
+
+  const { dir, projectId, baseURL, cfg, client, mgr, savedRemote } = ctx;
+  const asJson = !!args.json;
+  const short = !!args.short;
+  const lastSync = savedRemote && savedRemote.lastSync;
+
+  if (!asJson) {
+    ui.info(
+      `Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — comparando ${ui.c.dim(dir)} ...`
+    );
+  }
+
+  // 1) Árbol local (offline) y remoto (sólo listados).
+  const local = sync.walkLocal(dir);
+
+  let tree;
+  try {
+    tree = await sync.walkRemote(client, projectId, mgr);
+  } catch (e) {
+    ui.error(`No se pudo consultar el proyecto: ${e.message}`);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  // 2) Atribución: quién tocó cada archivo por última vez (best-effort).
+  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);
+
+  // 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.
+  const behind = [];
+  for (const item of cmp.onlyRemote) {
+    behind.push({ ...item, kind: 'falta local' });
+  }
+  for (const item of cmp.differing) {
+    if (sync.changedSinceSync(item.remote, lastSync) !== false) {
+      behind.push({ ...item, kind: 'difiere' });
+    }
+  }
+  behind.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
+
+  // 4) "Adelante" = lo que yo tengo y el remoto no refleja.
+  const ahead = [
+    ...cmp.onlyLocal.map((i) => ({ ...i, kind: 'nuevo local' })),
+    ...cmp.differing.map((i) => ({ ...i, kind: 'modificado local' })),
+  ].sort((a, b) => a.repoPath.localeCompare(b.repoPath));
+
+  const decorate = (item) => {
+    const meta = item.remote && attribution.index.get(item.remote.id);
+    if (!meta) return null;
+    return {
+      author: meta.author,
+      mine: !!(me && meta.authorId && meta.authorId === me),
+      date: meta.date,
+      message: meta.message,
+    };
+  };
+
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        {
+          projectId,
+          baseURL,
+          dir,
+          lastSync: lastSync || null,
+          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 })),
+          unchanged: cmp.same.length,
+          listErrors: tree.errors,
+        },
+        null,
+        2
+      )
+    );
+    return behind.length > 0 ? 2 : 0;
+  }
+
+  // 5) Reporte legible.
+  for (const err of tree.errors) {
+    ui.warn(`no se pudo listar ${ui.c.dim(err.folderPath || '(raíz)')} — ${err.reason}`);
+  }
+
+  ui.info('');
+  if (lastSync) {
+    ui.info(ui.c.dim(`Última sincronización de esta carpeta: ${sync.formatDate(lastSync)}`));
+  } else {
+    ui.info(
+      ui.c.dim(
+        `Esta carpeta no registra una sincronización previa ` +
+          `(hacé un pull o push para que ${remote.REMOTE_FILENAME} la anote).`
+      )
+    );
+  }
+  ui.info('');
+
+  if (behind.length === 0 && ahead.length === 0) {
+    ui.success(`Al día: ${cmp.same.length} archivo(s) coinciden con el remoto.`);
+    return 0;
+  }
+
+  if (behind.length > 0) {
+    ui.info(ui.c.bold(`El remoto tiene ${behind.length} cambio(s) que no tenés localmente:`));
+    for (const item of behind) {
+      const mark = item.kind === 'falta local' ? ui.c.green('↓') : ui.c.yellow('≠');
+      const meta = decorate(item);
+      let suffix = '';
+      if (meta) {
+        const who = meta.mine ? ui.c.dim('vos') : ui.c.bold(meta.author);
+        suffix = ui.c.dim(` — último commit de `) + who + ui.c.dim(`, ${sync.formatDate(meta.date)}`);
+      } else if (item.remote && item.remote.updated_at) {
+        suffix = ui.c.dim(` — actualizado ${sync.formatDate(item.remote.updated_at)}`);
+      }
+      ui.info(`  ${mark} ${item.repoPath}${short ? '' : suffix}`);
+    }
+    ui.info('');
+  }
+
+  if (ahead.length > 0) {
+    ui.info(ui.c.bold(`Tenés ${ahead.length} cambio(s) local(es) sin subir:`));
+    for (const item of ahead) {
+      const mark = item.kind === 'nuevo local' ? ui.c.green('+') : ui.c.yellow('~');
+      ui.info(`  ${mark} ${item.repoPath}`);
+    }
+    ui.info('');
+  }
+
+  ui.info(
+    ui.c.dim(
+      `  ${cmp.same.length} sin cambios (por tamaño)   ` +
+        `${local.ignored} ignorados   ${local.skipped.length} saltados`
+    )
+  );
+
+  // Los archivos que aparecen en ambas listas son el caso peligroso: el push
+  // los pisaría sin traerse antes lo del otro.
+  const conflicting = ahead.filter((a) => behind.some((b) => b.repoPath === a.repoPath));
+  ui.info('');
+  if (conflicting.length > 0) {
+    ui.warn(
+      `${conflicting.length} archivo(s) cambiaron de los dos lados: un push los pisaría.`
+    );
+    for (const item of conflicting) ui.info(`  ${ui.c.red('!')} ${item.repoPath}`);
+    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 {
+    ui.info(ui.c.dim('Sugerido: "shilo push --dry-run" para ver qué subiría.'));
+  }
+
+  // Exit code 2 = "estás desactualizado". Útil para encadenar en scripts:
+  // `shilo status || echo "bajá antes de trabajar"`.
+  return behind.length > 0 ? 2 : 0;
+}
+
+module.exports = status;

package/src/context.js

@@ -0,0 +1,82 @@
+'use strict';
+
+/**
+ * Resolución del contexto común a los comandos que hablan con un proyecto:
+ * carpeta -> remote (.shilo.json) -> sesión -> cliente HTTP.
+ *
+ * Los comandos de sólo lectura (`status`, `log`, `diff`) comparten exactamente
+ * este preámbulo; tenerlo en un lugar evita que cada uno resuelva el proyecto o
+ * el baseURL con reglas ligeramente distintas.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const config = require('./config');
+const remote = require('./remote');
+const ui = require('./ui');
+const sync = require('./sync');
+const { ShiloClient } = require('./ShiloClient');
+
+const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+
+/**
+ * Devuelve `{ ok: true, dir, projectId, baseURL, cfg, client, mgr, savedRemote }`
+ * o `{ ok: false, code }` habiendo ya impreso el error.
+ *
+ * `requireDir`: exige que la carpeta exista (todos menos `pull`, que la crea).
+ */
+function resolveContext(args, { requireDir = true } = {}) {
+  const dir = path.resolve(args._[0] || '.');
+
+  if (requireDir && (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())) {
+    ui.error(`No es una carpeta válida: ${dir}`);
+    return { ok: false, code: 1 };
+  }
+
+  let savedRemote = null;
+  try {
+    savedRemote = remote.read(dir);
+  } catch (e) {
+    ui.error(e.message);
+    return { ok: false, code: 1 };
+  }
+
+  const projectId =
+    (typeof args.project === 'string' && args.project.trim()) ||
+    (savedRemote && savedRemote.projectId) ||
+    null;
+
+  if (!projectId) {
+    ui.error('No hay proyecto configurado en esta carpeta.');
+    ui.info('Pasá --project <uuid> o corré "shilo init --project <uuid>" primero.');
+    return { ok: false, code: 1 };
+  }
+
+  const cfg = config.load();
+  if (!cfg || !cfg.credentials) {
+    ui.error('No hay sesión activa. Ejecutá "shilo login" primero.');
+    return { ok: false, code: 1 };
+  }
+
+  const baseURL =
+    args['base-url'] || (savedRemote && savedRemote.baseURL) || cfg.baseURL || DEFAULT_BASE_URL;
+
+  const client = new ShiloClient({
+    baseURL,
+    supabaseUrl: cfg.supabaseUrl || null,
+    supabaseAnonKey: cfg.supabaseAnonKey || null,
+  });
+
+  return {
+    ok: true,
+    dir,
+    projectId,
+    baseURL,
+    cfg,
+    client,
+    mgr: sync.makeCredsManager(client, cfg),
+    savedRemote,
+  };
+}
+
+module.exports = { resolveContext, DEFAULT_BASE_URL };