shilo-cli 0.2.0 → 0.3.1

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 };

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,
+};