shilo-cli 0.8.0 → 0.10.0

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,8 +62,25 @@ 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.
@@ -99,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(
@@ -106,7 +161,9 @@ 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) })),
@@ -130,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(
@@ -157,8 +214,35 @@ async function status(args) {
     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;
@@ -182,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}`);
@@ -194,7 +281,7 @@ async function status(args) {
 
   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`
     )
   );
@@ -211,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;

package/src/commands/sync.js

@@ -0,0 +1,240 @@
+'use strict';
+
+/**
+ * `shilo sync` — respaldo de las carpetas conectadas (PLAN_SINCRONIZAR, Etapa 1).
+ *
+ *   shilo sync                  lista las carpetas registradas y su último sync
+ *   shilo sync --all            sube todas, una tras otra
+ *   shilo sync <carpeta|uuid>   sube sólo esa (por ruta o por id de proyecto)
+ *   shilo sync --scan [raíz]    registra las carpetas atadas que haya bajo raíz
+ *   shilo sync --forget <dir>   saca una carpeta del registro (no toca el disco)
+ *
+ * Sincronizar es SUBIR: cada carpeta pasa por `shilo push --yes`, con todas sus
+ * garantías — un conflicto queda como propuesta abierta sin pisar a nadie, y una
+ * carpeta con posibles secretos no sube nada. Cada push corre en su propio
+ * proceso: lo que falle en una carpeta no arrastra a las demás.
+ *
+ * Una carpeta sin `base` en su `.shilo.json` se saltea (ver `checkFolder`).
+ *
+ * Un respaldo no despliega: se manda `--deploy off` salvo que se pida otra cosa,
+ * porque con `auto_target = production` un respaldo nocturno iría a producción.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const folders = require('../folders');
+const remote = require('../remote');
+const ui = require('../ui');
+
+const BIN = path.join(__dirname, '..', '..', 'bin', 'shilo.js');
+// Un prefijo del id alcanza (como un hash corto de git), pero no menos de 4.
+const UUID_RE = /^[0-9a-f-]{4,36}$/i;
+
+async function sync(args) {
+  if (args.forget !== undefined) return forget(args.forget);
+  if (args.scan !== undefined) return scan(args.scan === true ? '.' : args.scan);
+
+  let entries;
+  try {
+    entries = folders.load();
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+
+  const target = args._[0];
+  if (!args.all && !target) return list(entries);
+
+  let selected;
+  if (args.all) {
+    selected = entries;
+  } else {
+    selected = resolveTarget(target, entries);
+    if (!selected) return 1;
+  }
+
+  if (selected.length === 0) {
+    ui.warn('No hay carpetas registradas.');
+    ui.info('Corré "shilo sync --scan <carpeta>" para encontrar las que ya están conectadas.');
+    return 0;
+  }
+
+  const deploy = typeof args.deploy === 'string' ? args.deploy : 'off';
+  const message =
+    typeof args.message === 'string' && args.message.trim()
+      ? args.message.trim()
+      : `Respaldo (shilo sync) ${new Date().toLocaleString('es-AR')}`;
+
+  const results = [];
+  for (const [i, entry] of selected.entries()) {
+    ui.info('');
+    ui.info(ui.c.bold(`[${i + 1}/${selected.length}] ${entry.dir}`));
+
+    const check = checkFolder(entry);
+    if (check.problem) {
+      ui.warn(check.problem);
+      results.push({ dir: entry.dir, status: 'salteada', detail: check.problem });
+      continue;
+    }
+
+    const pushArgs = ['push', entry.dir, '--yes', '-m', message, '--deploy', deploy];
+    if (args['dry-run']) pushArgs.push('--dry-run');
+    const code = await runChild(pushArgs);
+    results.push(resultFor(entry.dir, code));
+  }
+
+  return summarize(results, !!args['dry-run']);
+}
+
+/** Código de salida de `push` → fila del resumen. */
+function resultFor(dir, code) {
+  if (code === 0) return { dir, status: 'ok', detail: '' };
+  // 3 = todo guardado, pero el proyecto exige aprobación: el respaldo está hecho.
+  if (code === 3) return { dir, status: 'ok', detail: 'guardado; la propuesta espera aprobación' };
+  return { dir, status: 'falló', detail: `push salió con código ${code} (ver arriba)` };
+}
+
+/** Lista el registro con el estado que dice cada `.shilo.json`. */
+function list(entries) {
+  if (entries.length === 0) {
+    ui.info('No hay carpetas registradas todavía.');
+    ui.info(
+      ui.c.dim(
+        'Se registran solas con init, push o pull; las ya conectadas se suman con "shilo sync --scan <carpeta>".'
+      )
+    );
+    return 0;
+  }
+  ui.info(ui.c.bold(`Carpetas conectadas (${entries.length}):`));
+  for (const entry of entries) {
+    const check = checkFolder(entry);
+    const when = check.remote && check.remote.lastSync
+      ? new Date(check.remote.lastSync).toLocaleString('es-AR')
+      : 'nunca';
+    const state = check.problem ? ui.c.yellow(check.problem) : ui.c.dim(`último sync: ${when}`);
+    ui.info(`  ${entry.dir}`);
+    ui.info(`    ${ui.c.dim(entry.projectId || '?')}  ${state}`);
+  }
+  ui.info('');
+  ui.info(ui.c.dim('"shilo sync --all" las sube todas; "shilo sync <carpeta|uuid>" sólo una.'));
+  return 0;
+}
+
+/**
+ * `<carpeta|uuid>` → lista de una entrada. Una carpeta existente que no estaba
+ * en el registro se registra (si está atada).
+ */
+function resolveTarget(target, entries) {
+  const abs = path.resolve(target);
+  if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
+    const r = safeRead(abs);
+    if (!r || !r.projectId) {
+      ui.error(`La carpeta no está conectada a Shilo (no tiene .shilo.json): ${abs}`);
+      return null;
+    }
+    folders.add(abs, r.projectId);
+    return [{ dir: abs, projectId: r.projectId }];
+  }
+
+  if (UUID_RE.test(target)) {
+    const t = target.toLowerCase();
+    const matches = entries.filter((e) => e.projectId && e.projectId.toLowerCase().startsWith(t));
+    if (matches.length > 0) return matches; // un proyecto atado en dos carpetas: las dos
+  }
+
+  ui.error(`No encontré "${target}" ni como carpeta ni como proyecto registrado.`);
+  ui.info('Corré "shilo sync" para ver la lista.');
+  return null;
+}
+
+/** ¿Se puede sincronizar? Devuelve `{ remote, problem }`. */
+function checkFolder(entry) {
+  if (!fs.existsSync(entry.dir)) {
+    return { remote: null, problem: 'la carpeta ya no existe ("shilo sync --forget" para sacarla)' };
+  }
+  const r = safeRead(entry.dir);
+  if (!r || !r.projectId) {
+    return { remote: null, problem: 'ya no tiene .shilo.json (¿se desconectó?)' };
+  }
+  if (r.projectId !== entry.projectId) folders.addQuietly(entry.dir, r.projectId);
+  // Sin `base`, el push toma el main actual como base y trata como cambios
+  // todos los archivos locales que difieren: una copia vieja pisaría trabajo
+  // más nuevo (pasó el 2026-10-12). Eso no puede pasar sin que alguien mire.
+  if (!r.base) return { remote: r, problem: NO_BASE };
+  return { remote: r, problem: null };
+}
+
+const NO_BASE =
+  'requiere atención: sin "base" en .shilo.json no sé si está al día. Revisala con ' +
+  '"shilo status" y "shilo diff", y subila a mano una vez con "shilo push" (o "shilo pull" si está atrasada)';
+
+function safeRead(dir) {
+  try {
+    return remote.read(dir);
+  } catch (_) {
+    return null;
+  }
+}
+
+function scan(root) {
+  const abs = path.resolve(root);
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+    ui.error(`No es una carpeta válida: ${abs}`);
+    return 1;
+  }
+  ui.info(ui.c.dim(`Buscando carpetas conectadas bajo ${abs}…`));
+  const found = folders.scan(abs);
+  let added = 0;
+  for (const f of found) {
+    const isNew = folders.add(f.dir, f.projectId);
+    if (isNew) added++;
+    ui.info(`  ${isNew ? ui.c.green('+') : ui.c.dim('=')} ${f.dir}`);
+  }
+  if (found.length === 0) ui.info('No encontré ninguna carpeta con .shilo.json.');
+  else ui.success(`${found.length} encontrada(s), ${added} nueva(s) en el registro.`);
+  return 0;
+}
+
+function forget(dir) {
+  if (dir === true) {
+    ui.error('Falta la carpeta: shilo sync --forget <carpeta>');
+    return 1;
+  }
+  if (folders.remove(dir)) {
+    ui.success(`Sacada del registro: ${path.resolve(dir)}`);
+    ui.info(ui.c.dim('No se tocó nada en disco; un push o pull futuro la vuelve a registrar.'));
+    return 0;
+  }
+  ui.warn(`No estaba en el registro: ${path.resolve(dir)}`);
+  return 0;
+}
+
+function runChild(argv) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [BIN, ...argv], { stdio: 'inherit' });
+    child.on('error', (e) => {
+      ui.error(`No se pudo lanzar el push: ${e.message}`);
+      resolve(1);
+    });
+    child.on('close', (code) => resolve(typeof code === 'number' ? code : 1));
+  });
+}
+
+function summarize(results, dryRun) {
+  ui.info('');
+  ui.info(ui.c.bold('Resumen del respaldo:'));
+  for (const r of results) {
+    const mark =
+      r.status === 'ok' ? ui.c.green('✓') : r.status === 'salteada' ? ui.c.yellow('!') : ui.c.red('✗');
+    ui.info(`  ${mark} ${r.dir}${r.detail ? ui.c.dim(` — ${r.detail}`) : ''}`);
+  }
+  const ok = results.filter((r) => r.status === 'ok').length;
+  const bad = results.length - ok;
+  const verb = dryRun ? 'revisada(s) (--dry-run: no se subió nada)' : 'respaldada(s)';
+  if (bad === 0) ui.success(`${ok} carpeta(s) ${verb}.`);
+  else ui.warn(`${ok} ${verb}, ${bad} con problemas.`);
+  return bad === 0 ? 0 : 1;
+}
+
+module.exports = sync;

package/src/folders.js

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * Registro local de carpetas conectadas: `~/.shilo/carpetas.json`.
+ *
+ * El servidor conoce los proyectos, pero no en qué carpetas de qué máquina
+ * está atado cada uno: eso sólo lo sabe el disco (cada `.shilo.json`). Este
+ * registro es la lista que `shilo sync --all` recorre (PLAN_SINCRONIZAR, Etapa 1).
+ *
+ * Se llena solo: `remote.write` —el único lugar donde se escribe un
+ * `.shilo.json`, lo usen `init`, `pull` o `push`— registra la carpeta. Las que
+ * se ataron antes de que existiera el registro se suman con `shilo sync --scan`.
+ *
+ * Estructura en disco:
+ * {
+ *   "version": 1,
+ *   "carpetas": [
+ *     { "dir": "C:\\...\\boda", "projectId": "<uuid>", "addedAt": "<ISO>" }
+ *   ]
+ * }
+ *
+ * No guarda credenciales ni el estado de sincronización: el estado vive en el
+ * `.shilo.json` de cada carpeta (`lastSync`), que es la fuente de verdad.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+const remote = require('./remote');
+
+const FILENAME = 'carpetas.json';
+
+// Lo que `--scan` no recorre: pesado y nunca contiene una carpeta atada propia.
+const SCAN_SKIP = new Set(['node_modules', '.git', '.shilo', '.vercel', 'dist', 'build']);
+
+function registryPath() {
+  return path.join(config.configDir(), FILENAME);
+}
+
+/** En Windows y macOS las rutas no distinguen mayúsculas: una carpeta, una entrada. */
+function keyOf(dir) {
+  const abs = path.resolve(dir);
+  return process.platform === 'linux' ? abs : abs.toLowerCase();
+}
+
+function load() {
+  const p = registryPath();
+  if (!fs.existsSync(p)) return [];
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(p, 'utf8').replace(/^/, ''));
+  } catch (e) {
+    throw new Error(`Registro de carpetas corrupto en ${p}: ${e.message}`);
+  }
+  return Array.isArray(raw.carpetas) ? raw.carpetas.filter((c) => c && typeof c.dir === 'string') : [];
+}
+
+function save(list) {
+  fs.mkdirSync(config.configDir(), { recursive: true });
+  const p = registryPath();
+  fs.writeFileSync(p, JSON.stringify({ version: 1, carpetas: list }, null, 2) + '\n', 'utf8');
+  return p;
+}
+
+/**
+ * Registra (o actualiza el proyecto de) una carpeta. Devuelve `true` si era nueva.
+ */
+function add(dir, projectId) {
+  const abs = path.resolve(dir);
+  const list = load();
+  const k = keyOf(abs);
+  const found = list.find((c) => keyOf(c.dir) === k);
+  if (found) {
+    if (projectId && found.projectId !== projectId) {
+      found.projectId = projectId;
+      save(list);
+    }
+    return false;
+  }
+  list.push({ dir: abs, projectId: projectId || null, addedAt: new Date().toISOString() });
+  save(list);
+  return true;
+}
+
+/**
+ * Versión para `remote.write`: registrar nunca puede romper un push o un pull
+ * (config de sólo lectura, registro corrupto, etc.).
+ */
+function addQuietly(dir, projectId) {
+  try {
+    add(dir, projectId);
+  } catch (_) {
+    /* el registro es una comodidad, no un requisito */
+  }
+}
+
+/** Saca una carpeta del registro. Devuelve `true` si estaba. */
+function remove(dir) {
+  const k = keyOf(dir);
+  const list = load();
+  const rest = list.filter((c) => keyOf(c.dir) !== k);
+  if (rest.length === list.length) return false;
+  save(rest);
+  return true;
+}
+
+/**
+ * Busca `.shilo.json` bajo `root` (incluida) hasta `maxDepth` niveles.
+ * No entra en una carpeta atada: un repo de Shilo no contiene otro.
+ * Devuelve `[{ dir, projectId }]`.
+ */
+function scan(root, { maxDepth = 6 } = {}) {
+  const found = [];
+  const walk = (dir, depth) => {
+    let info = null;
+    try {
+      info = remote.read(dir);
+    } catch (_) {
+      /* `.shilo.json` corrupto: no es una carpeta sincronizable */
+    }
+    if (info && info.projectId) {
+      found.push({ dir, projectId: info.projectId });
+      return;
+    }
+    if (depth >= maxDepth) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (_) {
+      return; // sin permiso de lectura
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || SCAN_SKIP.has(e.name)) continue;
+      walk(path.join(dir, e.name), depth + 1);
+    }
+  };
+  walk(path.resolve(root), 0);
+  return found;
+}
+
+module.exports = { registryPath, load, add, addQuietly, remove, scan, keyOf };

package/src/projectconfig.js

@@ -0,0 +1,76 @@
+/**
+ * `shilo.config.json` del lado del CLI (EP-S2): **espejo** de
+ * `backend/utils/projectConfig.js`, que es donde está explicado el porqué.
+ * El CLI no puede importar del backend; `backend/utils/__tests__/projectConfig.test.js`
+ * corre los dos sobre las mismas entradas para que no se separen.
+ *
+ * El CLI la lee de la carpeta local: los chequeos (MU-93) se corren antes de
+ * proponer, con lo que hay en disco.
+ */
+
+'use strict';
+
+const CONFIG_PATH = 'shilo.config.json';
+const UNIONES = ['archivo', 'lineas'];
+const MAX_CHEQUEOS = 10;
+const MAX_COMANDO = 500;
+
+/** Los comandos válidos de `chequeos`, anotando en `avisos` lo que se ignora. */
+function parseChequeos(raw, avisos) {
+  if (!Array.isArray(raw)) {
+    avisos.push('"chequeos" debe ser una lista de comandos');
+    return [];
+  }
+  const out = [];
+  for (const cmd of raw) {
+    if (typeof cmd !== 'string' || !cmd.trim() || cmd.length > MAX_COMANDO) {
+      avisos.push('Se ignoró un chequeo que no es un comando de texto');
+    } else if (out.length >= MAX_CHEQUEOS) {
+      avisos.push(`Más de ${MAX_CHEQUEOS} chequeos: se ignoran los demás`);
+      break;
+    } else {
+      out.push(cmd.trim());
+    }
+  }
+  return out;
+}
+
+/** El objeto de `shilo.config.json`, o null con el aviso de por qué no. */
+function parseObject(text, avisos) {
+  let raw;
+  try {
+    const clean = String(text);
+    // Sin BOM: JSON.parse no lo acepta y algunos editores de Windows lo ponen.
+    raw = JSON.parse(clean.charCodeAt(0) === 0xfeff ? clean.slice(1) : clean);
+  } catch (err) {
+    avisos.push(`${CONFIG_PATH} no es JSON válido: se usan los valores por defecto`);
+    return null;
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    avisos.push(`${CONFIG_PATH} debe ser un objeto: se usan los valores por defecto`);
+    return null;
+  }
+  return raw;
+}
+
+/**
+ * @param {string|null|undefined} text - contenido de `shilo.config.json`
+ * @returns {{ union: 'archivo'|'lineas', chequeos: string[], avisos: string[] }}
+ */
+function parseProjectConfig(text) {
+  const config = { union: 'archivo', chequeos: [], avisos: [] };
+  if (text === null || text === undefined || String(text).trim() === '') return config;
+
+  const raw = parseObject(text, config.avisos);
+  if (!raw) return config;
+
+  if (raw.union !== undefined) {
+    if (UNIONES.includes(raw.union)) config.union = raw.union;
+    else config.avisos.push(`"union" debe ser ${UNIONES.join(' o ')}: se usa "archivo"`);
+  }
+  if (raw.chequeos !== undefined) config.chequeos = parseChequeos(raw.chequeos, config.avisos);
+
+  return config;
+}
+
+module.exports = { CONFIG_PATH, UNIONES, MAX_CHEQUEOS, parseProjectConfig };

package/src/remote.js

@@ -72,6 +72,9 @@ function write(dir, { projectId, baseURL, lastSync, base }) {
   if (lastSync) onDisk.lastSync = lastSync;
   if (base) onDisk.base = base;
   fs.writeFileSync(p, JSON.stringify(onDisk, null, 2) + '\n', 'utf8');
+  // Toda carpeta atada queda en el registro de `shilo sync --all`. Require
+  // perezoso: `folders` ya depende de este módulo.
+  require('./folders').addQuietly(dir, projectId);
   return p;
 }