shilo-cli 0.2.0 → 0.3.0

package/src/remote.js

@@ -10,9 +10,14 @@
  * Estructura en disco:
  * {
  *   "projectId": "<uuid>",
- *   "baseURL": "https://shilo-six.vercel.app"
+ *   "baseURL": "https://shilo-six.vercel.app",
+ *   "lastSync": "2026-07-27T12:00:00.000Z"
  * }
  *
+ * `lastSync` es la marca de la última vez que esta carpeta quedó alineada con
+ * el remoto (fin de un push o pull exitoso). `status` la usa para distinguir
+ * "el remoto cambió desde que sincronicé" de "esto lo subí yo".
+ *
  * NO contiene credenciales (esas están en ~/.shilo/config.json, cifradas), así
  * que es seguro commitearlo al repo si el usuario quiere.
  */
@@ -42,18 +47,39 @@ function read(dir) {
   return {
     projectId: raw.projectId || null,
     baseURL: raw.baseURL || null,
+    lastSync: raw.lastSync || null,
   };
 }
 
 /**
  * Escribe `.shilo.json` en `dir`. Devuelve la ruta escrita.
  */
-function write(dir, { projectId, baseURL }) {
+function write(dir, { projectId, baseURL, lastSync }) {
   const p = remotePath(dir);
   const onDisk = { projectId };
   if (baseURL) onDisk.baseURL = baseURL;
+  if (lastSync) onDisk.lastSync = lastSync;
   fs.writeFileSync(p, JSON.stringify(onDisk, null, 2) + '\n', 'utf8');
   return p;
 }
 
-module.exports = { REMOTE_FILENAME, remotePath, read, write };
+/**
+ * Marca la carpeta como sincronizada ahora mismo, conservando el resto del
+ * remote. No es fatal si falla (la carpeta puede ser de sólo lectura): devuelve
+ * `false` y el caller decide si avisar.
+ */
+function touchSync(dir, { projectId, baseURL } = {}) {
+  try {
+    const current = read(dir) || {};
+    write(dir, {
+      projectId: projectId || current.projectId,
+      baseURL: baseURL || current.baseURL,
+      lastSync: new Date().toISOString(),
+    });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+module.exports = { REMOTE_FILENAME, remotePath, read, write, touchSync };

package/src/sync.js

@@ -0,0 +1,344 @@
+'use strict';
+
+/**
+ * Piezas compartidas entre `pull`, `status`, `diff`, `log` y `push`:
+ * recorrido del árbol remoto, comparación local↔remoto y atribución de
+ * cambios a partir del historial de commits.
+ *
+ * Todo lo de acá es de sólo lectura: ninguna función escribe en disco ni en el
+ * servidor. La idea es que un `shilo status` pueda contestar "¿estoy
+ * desactualizado?" sin bajar contenido.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+const { walk } = require('./walk');
+
+const CONCURRENCY = 8; // pool para el N+1 de listar carpetas (el backend no tiene árbol recursivo)
+
+// Mime types que sabemos que vuelven como texto legible. El backend siempre
+// devuelve el contenido vía `data.text()`, así que un binario (p.ej. image/png
+// subido desde la web) volvería corrupto: esos se saltean.
+const TEXT_MIME_EXTRA = new Set([
+  'application/json', 'application/xml', 'application/javascript',
+  'application/typescript', 'application/yaml', 'application/x-yaml',
+  'image/svg+xml',
+]);
+
+function isTextMime(mime) {
+  if (!mime) return true; // el backend default para archivos es text/plain
+  const m = String(mime).toLowerCase().split(';')[0].trim();
+  return m.startsWith('text/') || TEXT_MIME_EXTRA.has(m);
+}
+
+/**
+ * Gestor de credenciales con refresh serializado.
+ *
+ * El recorrido remoto dispara muchos requests en paralelo (pool). Si dos toparan
+ * con el JWT casi vencido a la vez, cada uno intentaría refrescar con el mismo
+ * refresh_token —que Supabase invalida tras el primer uso— y la sesión se
+ * rompería. Este gestor centraliza el refresh en una sola promesa compartida y
+ * entrega credenciales ya válidas, de modo que el `ensureValidToken` interno de
+ * cada request sea no-op.
+ */
+function makeCredsManager(client, cfg) {
+  let creds = cfg.credentials;
+  let refreshing = null;
+
+  return {
+    get current() {
+      return creds;
+    },
+    async valid() {
+      if (creds && creds.kind === 'pat') return creds;
+      const msLeft = new Date(creds.expiresAt).getTime() - Date.now();
+      if (msLeft >= 5 * 60 * 1000) return creds;
+
+      if (!refreshing) {
+        refreshing = (async () => {
+          const fresh = await client.ensureValidToken(creds);
+          if (fresh !== creds) {
+            creds = fresh;
+            config.persistCredsIfChanged(cfg, creds);
+          }
+          return creds;
+        })().finally(() => {
+          refreshing = null;
+        });
+      }
+      return refreshing;
+    },
+  };
+}
+
+/**
+ * Corre `worker(item)` sobre `items` con concurrencia limitada. Preserva el
+ * orden de `items` en el array de resultados. Un worker que lanza deja el hueco
+ * como `{ __error: <msg>, item }` para que el caller decida.
+ */
+async function runPool(items, concurrency, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+
+  async function drain() {
+    while (next < items.length) {
+      const i = next++;
+      try {
+        results[i] = await worker(items[i], i);
+      } catch (e) {
+        results[i] = { __error: e.message, item: items[i] };
+      }
+    }
+  }
+
+  const runners = [];
+  for (let k = 0; k < Math.min(concurrency, items.length); k++) {
+    runners.push(drain());
+  }
+  await Promise.all(runners);
+  return results;
+}
+
+/**
+ * Recorre el árbol remoto de un proyecto listando carpeta por carpeta (BFS con
+ * pool). El backend no expone un endpoint recursivo, así que es N+1: un request
+ * por carpeta, pero ninguno baja contenido. Devuelve `{ files, errors }`:
+ *   files: [{ repoPath, name, id, size, mime_type, updated_at }]
+ *   errors: [{ folderPath, reason }]
+ */
+async function walkRemote(client, projectId, mgr) {
+  const files = [];
+  const errors = [];
+  let frontier = ['']; // rutas de carpeta a listar; '' = raíz
+
+  while (frontier.length > 0) {
+    const listed = await runPool(frontier, CONCURRENCY, async (folderPath) => {
+      const creds = await mgr.valid();
+      const { files: entries } = await client.listFiles(projectId, creds, folderPath);
+      return { folderPath, entries };
+    });
+
+    const nextFrontier = [];
+    for (const res of listed) {
+      if (res && res.__error) {
+        errors.push({ folderPath: res.item, reason: res.__error });
+        continue;
+      }
+      const { folderPath, entries } = res;
+      for (const entry of entries) {
+        const repoPath = folderPath ? `${folderPath}/${entry.name}` : entry.name;
+        if (entry.type === 'folder') {
+          nextFrontier.push(repoPath);
+        } else {
+          files.push({
+            repoPath,
+            name: entry.name,
+            id: entry.id,
+            size: entry.size,
+            mime_type: entry.mime_type,
+            updated_at: entry.updated_at || entry.created_at || null,
+          });
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+
+  files.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
+  return { files, errors };
+}
+
+/**
+ * Árbol local en el mismo formato que el remoto, aplicando los mismos ignores
+ * que usa `push` (para que la comparación sea manzanas con manzanas).
+ * Devuelve `{ files: [{ repoPath, absPath, size }], skipped, ignored }`.
+ */
+function walkLocal(dir) {
+  const { files, skipped, ignored } = walk(dir);
+  return {
+    files: files
+      .map((f) => ({ repoPath: f.relPath, absPath: f.absPath, size: f.size }))
+      .sort((a, b) => a.repoPath.localeCompare(b.repoPath)),
+    skipped,
+    ignored,
+  };
+}
+
+/**
+ * Compara los dos árboles por ruta y tamaño. NO baja contenido: por eso un
+ * archivo con el mismo tamaño en ambos lados cae en `same` aunque su contenido
+ * pudiera diferir (mismo largo, distinto texto). Esa es la concesión que hace
+ * que `status` sea barato; `diff` y `push` sí confirman byte a byte.
+ *
+ * Devuelve:
+ *   {
+ *     onlyLocal:  [{ repoPath, local }],          // sin subir
+ *     onlyRemote: [{ repoPath, remote }],         // sin bajar
+ *     differing:  [{ repoPath, local, remote }],  // tamaños distintos
+ *     same:       [{ repoPath, local, remote }],  // mismo tamaño
+ *   }
+ */
+function compareTrees(localFiles, remoteFiles) {
+  const localByPath = new Map(localFiles.map((f) => [f.repoPath, f]));
+  const remoteByPath = new Map(remoteFiles.map((f) => [f.repoPath, f]));
+
+  const onlyLocal = [];
+  const onlyRemote = [];
+  const differing = [];
+  const same = [];
+
+  for (const [repoPath, local] of localByPath) {
+    const remote = remoteByPath.get(repoPath);
+    if (!remote) {
+      onlyLocal.push({ repoPath, local });
+    } else if (typeof remote.size === 'number' && remote.size !== local.size) {
+      differing.push({ repoPath, local, remote });
+    } else {
+      same.push({ repoPath, local, remote });
+    }
+  }
+
+  for (const [repoPath, remote] of remoteByPath) {
+    if (!localByPath.has(repoPath)) onlyRemote.push({ repoPath, remote });
+  }
+
+  const byPath = (a, b) => a.repoPath.localeCompare(b.repoPath);
+  onlyLocal.sort(byPath);
+  onlyRemote.sort(byPath);
+  differing.sort(byPath);
+  same.sort(byPath);
+
+  return { onlyLocal, onlyRemote, differing, same };
+}
+
+/**
+ * Baja las últimas páginas del historial con sus archivos y arma un índice
+ * `file_id -> { message, author, date, hash, action }` con el commit MÁS
+ * RECIENTE que tocó cada archivo. Sirve para responder "¿esto lo subí yo o me
+ * lo va a pisar otro?".
+ *
+ * Es best-effort: si el historial falla (permisos, red), devuelve un índice
+ * vacío en vez de romper el comando que lo pidió.
+ */
+async function buildAuthorIndex(client, projectId, mgr, { commits = 50 } = {}) {
+  const index = new Map();
+  let history = [];
+  try {
+    const creds = await mgr.valid();
+    const result = await client.listCommits(projectId, creds, {
+      limit: Math.min(commits, 100),
+      includeFiles: true,
+    });
+    history = result.commits;
+  } catch (_) {
+    return { index, commits: [], ok: false };
+  }
+
+  // El historial viene del más nuevo al más viejo: el primero que menciona un
+  // archivo es el último que lo tocó.
+  for (const commit of history) {
+    const author = describeAuthor(commit.users);
+    for (const cf of commit.files || []) {
+      const file = cf.files || {};
+      if (!file.id || index.has(file.id)) continue;
+      index.set(file.id, {
+        message: commit.message,
+        author,
+        authorId: commit.users ? commit.users.id : null,
+        date: commit.created_at,
+        hash: commit.hash,
+        action: cf.action,
+      });
+    }
+  }
+
+  return { index, commits: history, ok: true };
+}
+
+function describeAuthor(user) {
+  if (!user) return 'desconocido';
+  return user.username || user.display_name || 'desconocido';
+}
+
+/**
+ * Fecha absoluta corta + relativa ("2026-07-27 14:03, hace 2 h").
+ */
+function formatDate(iso) {
+  if (!iso) return 'sin fecha';
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return String(iso);
+  const pad = (n) => String(n).padStart(2, '0');
+  const abs =
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+    `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  return `${abs} (${relativeDate(d)})`;
+}
+
+function relativeDate(d) {
+  const secs = Math.round((Date.now() - d.getTime()) / 1000);
+  if (secs < 0) return 'en el futuro';
+  if (secs < 60) return 'recién';
+  const mins = Math.round(secs / 60);
+  if (mins < 60) return `hace ${mins} min`;
+  const hours = Math.round(mins / 60);
+  if (hours < 48) return `hace ${hours} h`;
+  const days = Math.round(hours / 24);
+  if (days < 60) return `hace ${days} d`;
+  return `hace ${Math.round(days / 30)} meses`;
+}
+
+/**
+ * ¿Un archivo remoto cambió después de la última sincronización local?
+ * Sin `lastSync` (carpeta atada a mano, o CLI viejo) devolvemos `null`:
+ * "no se sabe", que es distinto de "no cambió".
+ */
+function changedSinceSync(remoteFile, lastSync) {
+  if (!lastSync || !remoteFile || !remoteFile.updated_at) return null;
+  const t = new Date(remoteFile.updated_at).getTime();
+  const s = new Date(lastSync).getTime();
+  if (isNaN(t) || isNaN(s)) return null;
+  return t > s;
+}
+
+/**
+ * Lee un archivo local como texto. Devuelve `null` si no existe o no se puede
+ * leer como utf8.
+ */
+function readLocalText(absPath) {
+  try {
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) return null;
+    return fs.readFileSync(absPath, 'utf8');
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Normaliza una ruta que el usuario escribe en la terminal (puede venir con
+ * `\` de Windows, con `./` adelante, o absoluta) a una ruta de repo POSIX
+ * relativa a `dir`. Devuelve `null` si queda fuera de la carpeta.
+ */
+function toRepoPath(dir, userPath) {
+  const abs = path.resolve(dir, userPath);
+  const rel = path.relative(dir, abs);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join('/');
+}
+
+module.exports = {
+  CONCURRENCY,
+  isTextMime,
+  makeCredsManager,
+  runPool,
+  walkRemote,
+  walkLocal,
+  compareTrees,
+  buildAuthorIndex,
+  describeAuthor,
+  formatDate,
+  relativeDate,
+  changedSinceSync,
+  readLocalText,
+  toRepoPath,
+};

package/src/textdiff.js

@@ -0,0 +1,196 @@
+'use strict';
+
+/**
+ * Diff de texto por líneas, estilo unified, sin dependencias.
+ *
+ * Usado por `shilo diff` y por el `--dry-run` de push/pull para mostrar qué
+ * cambia realmente entre la versión local y la remota de un archivo.
+ *
+ * El algoritmo es LCS con programación dinámica: simple y exacto, pero O(n·m)
+ * en memoria. Para archivos grandes eso explota, así que por encima de
+ * `MAX_CELLS` se degrada a un resumen ("N líneas locales vs M remotas") en vez
+ * de intentar el diff completo.
+ */
+
+const MAX_CELLS = 4_000_000; // ~4M celdas: unos 2000x2000 líneas
+const DEFAULT_CONTEXT = 3;
+
+function splitLines(text) {
+  if (text === '' || text == null) return [];
+  const normalized = String(text).replace(/\r\n/g, '\n');
+  const lines = normalized.split('\n');
+  // Un texto terminado en \n produce un último elemento vacío que no es línea.
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+/**
+ * Matriz de longitudes LCS entre dos arrays de líneas.
+ */
+function lcsTable(a, b) {
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const table = new Array(rows);
+  for (let i = 0; i < rows; i++) table[i] = new Uint32Array(cols);
+
+  for (let i = a.length - 1; i >= 0; i--) {
+    for (let j = b.length - 1; j >= 0; j--) {
+      table[i][j] =
+        a[i] === b[j]
+          ? table[i + 1][j + 1] + 1
+          : Math.max(table[i + 1][j], table[i][j + 1]);
+    }
+  }
+  return table;
+}
+
+/**
+ * Secuencia de operaciones para transformar `a` en `b`.
+ * Devuelve [{ type: 'equal'|'del'|'add', line }] o `null` si es demasiado grande.
+ */
+function diffLines(a, b) {
+  if ((a.length + 1) * (b.length + 1) > MAX_CELLS) return null;
+
+  const table = lcsTable(a, b);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      ops.push({ type: 'equal', line: a[i] });
+      i++;
+      j++;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      ops.push({ type: 'del', line: a[i] });
+      i++;
+    } else {
+      ops.push({ type: 'add', line: b[j] });
+      j++;
+    }
+  }
+  while (i < a.length) ops.push({ type: 'del', line: a[i++] });
+  while (j < b.length) ops.push({ type: 'add', line: b[j++] });
+
+  return ops;
+}
+
+/**
+ * Agrupa las operaciones en hunks con `context` líneas de contexto, al estilo
+ * unified. Devuelve [{ aStart, aCount, bStart, bCount, ops }] (1-indexado).
+ */
+function toHunks(ops, context = DEFAULT_CONTEXT) {
+  // Índice de línea (1-based) de cada op en cada lado.
+  const annotated = [];
+  let aLine = 1;
+  let bLine = 1;
+  for (const op of ops) {
+    annotated.push({ ...op, aLine, bLine });
+    if (op.type === 'equal') {
+      aLine++;
+      bLine++;
+    } else if (op.type === 'del') {
+      aLine++;
+    } else {
+      bLine++;
+    }
+  }
+
+  const changed = annotated
+    .map((op, idx) => (op.type === 'equal' ? -1 : idx))
+    .filter((idx) => idx >= 0);
+  if (changed.length === 0) return [];
+
+  // Agrupar índices cambiados que estén a <= 2*context de distancia.
+  const groups = [];
+  let start = changed[0];
+  let end = changed[0];
+  for (const idx of changed.slice(1)) {
+    if (idx - end <= context * 2) {
+      end = idx;
+    } else {
+      groups.push([start, end]);
+      start = idx;
+      end = idx;
+    }
+  }
+  groups.push([start, end]);
+
+  return groups.map(([gStart, gEnd]) => {
+    const from = Math.max(0, gStart - context);
+    const to = Math.min(annotated.length - 1, gEnd + context);
+    const slice = annotated.slice(from, to + 1);
+
+    let aCount = 0;
+    let bCount = 0;
+    for (const op of slice) {
+      if (op.type !== 'add') aCount++;
+      if (op.type !== 'del') bCount++;
+    }
+
+    return {
+      aStart: aCount ? slice[0].aLine : 0,
+      aCount,
+      bStart: bCount ? slice[0].bLine : 0,
+      bCount,
+      ops: slice,
+    };
+  });
+}
+
+/**
+ * Diff completo entre dos textos.
+ * Devuelve:
+ *   { identical: true }
+ *   { tooBig: true, aLines, bLines }
+ *   { hunks, added, removed, aLines, bLines }
+ */
+function diffText(aText, bText, { context = DEFAULT_CONTEXT } = {}) {
+  const a = splitLines(aText);
+  const b = splitLines(bText);
+
+  if (aText === bText) return { identical: true, aLines: a.length, bLines: b.length };
+
+  const ops = diffLines(a, b);
+  if (!ops) return { tooBig: true, aLines: a.length, bLines: b.length };
+
+  const added = ops.filter((o) => o.type === 'add').length;
+  const removed = ops.filter((o) => o.type === 'del').length;
+  if (added === 0 && removed === 0) {
+    return { identical: true, aLines: a.length, bLines: b.length };
+  }
+
+  return { hunks: toHunks(ops, context), added, removed, aLines: a.length, bLines: b.length };
+}
+
+/**
+ * Render de un resultado de `diffText` a líneas de texto listas para imprimir.
+ * `paint` permite inyectar colores (`ui.c`); por defecto sale en plano.
+ */
+function renderDiff(result, { paint = null } = {}) {
+  const color = paint || { green: (s) => s, red: (s) => s, cyan: (s) => s, dim: (s) => s };
+  if (result.identical) return [];
+  if (result.tooBig) {
+    return [
+      color.dim(
+        `(archivo demasiado grande para diff línea a línea: ` +
+          `${result.aLines} líneas de un lado, ${result.bLines} del otro)`
+      ),
+    ];
+  }
+
+  const out = [];
+  for (const hunk of result.hunks) {
+    out.push(
+      color.cyan(`@@ -${hunk.aStart},${hunk.aCount} +${hunk.bStart},${hunk.bCount} @@`)
+    );
+    for (const op of hunk.ops) {
+      if (op.type === 'equal') out.push(color.dim(` ${op.line}`));
+      else if (op.type === 'del') out.push(color.red(`-${op.line}`));
+      else out.push(color.green(`+${op.line}`));
+    }
+  }
+  return out;
+}
+
+module.exports = { splitLines, diffLines, diffText, renderDiff, toHunks, MAX_CELLS };