shilo-cli 0.2.0 → 0.3.1

package/README.md

@@ -3,8 +3,9 @@
 CLI para subir carpetas locales a repositorios de [Shilo](https://shilo-six.vercel.app),
 con una experiencia tipo git: `shilo login` una vez y después `shilo push`.
 
-> **Estado:** Fase 3 (push). Disponibles `login`, `whoami`, `logout`, `init`, `push`.
-> El flujo completo tipo git ya funciona: `shilo login` → `shilo init` → `shilo push`.
+> **Estado:** Fase 5 (colaboración asíncrona). Disponibles `login`, `whoami`, `logout`,
+> `init`, `push`, `pull`, `status`, `log`, `diff`.
+> Ciclo completo: `shilo status` → `shilo pull` → trabajar local → `shilo push`.
 
 ## Requisitos
 
@@ -36,6 +37,7 @@ shilo init --project <uuid>       # ata la carpeta al repo (escribe .shilo.json)
 shilo push                        # sube: crea/actualiza + commit
 shilo push -m "mi mensaje"        # con mensaje de commit
 shilo push --dry-run              # muestra qué haría sin subir
+shilo push --card ABC-123         # agrega "[card: ABC-123]" al mensaje del commit
 shilo push --yes                  # sin pedir confirmación
 shilo push ./otra-carpeta --project <uuid>   # sin init, proyecto explícito
 ```
@@ -44,6 +46,78 @@ Sólo se suben archivos de **texto**; binarios, oversize (>25 MB) y nombres con
 caracteres no permitidos se saltan con aviso. Los archivos sin cambios no se
 re-suben. Ignorá rutas con un `.shiloignore` (sintaxis estilo `.gitignore`).
 
+En `--dry-run` (y antes de la confirmación interactiva) cada archivo modificado
+muestra **quién lo tocó por última vez y cuándo**, y se avisa explícitamente si vas
+a pisar el trabajo de otra persona. Con token de acceso personal el autor se muestra
+igual, pero no se puede marcar cuál sos vos (el PAT no expone tu id de usuario).
+
+### ¿Estoy desactualizado? (status)
+
+```bash
+shilo status            # compara local vs remoto SIN bajar contenido
+shilo status --short    # sólo rutas
+shilo status --json     # para scripts
+```
+
+Es el comando barato: usa sólo listados de carpeta (una request por carpeta, cero
+descargas de contenido) y compara por **ruta + tamaño**. Informa qué tiene el remoto
+que vos no (con autor y fecha del último commit de cada archivo), qué tenés local sin
+subir, y marca aparte los archivos que cambiaron **de los dos lados** — el caso
+peligroso. **Exit code 2** = estás atrasado respecto del remoto, útil en scripts.
+
+Compensación consciente: dos archivos del mismo tamaño se reportan como iguales
+aunque difieran byte a byte. `shilo diff` y `shilo push` sí comparan contenido.
+
+La comparación con "desde la última vez que sincronicé" se apoya en `lastSync`, que
+`push` y los `pull` completos escriben en `.shilo.json`. Si nunca sincronizaste desde
+esta carpeta, no hay línea de base y los cambios remotos se reportan igual.
+
+### Historial (log)
+
+```bash
+shilo log                       # últimos commits del proyecto
+shilo log src/app.js            # sólo los commits que tocaron ese archivo
+shilo log -n 50 --files         # más commits, listando archivos de cada uno
+shilo log --json
+```
+
+La paginación es **por commit**, no por archivo: si un archivo no aparece, subí `-n`.
+
+### Diferencias (diff)
+
+```bash
+shilo diff                # resumen de todo lo que difiere (sólo metadata)
+shilo diff src/app.js     # diff de contenido línea a línea
+shilo diff src/app.js --context 6
+shilo diff --stat
+```
+
+El diff usa el remoto como base (`---`) y tu copia local como destino (`+++`), o sea
+que las líneas `+` son lo que un `push` agregaría. **Exit code 1** = hay diferencias.
+
+### Bajar un proyecto (pull)
+
+```bash
+shilo pull ./mi-carpeta --project <uuid>   # baja el repo a una carpeta local
+shilo pull --dry-run                        # muestra qué cambiaría localmente, sin bajar nada
+shilo pull --yes                            # sin pedir confirmación
+shilo pull --force                          # sobrescribe también los archivos que difieren
+```
+
+`pull` recorre el árbol remoto (carpeta por carpeta), baja los archivos de texto
+y deja `.shilo.json` listo para un `push` posterior sin `--project`.
+
+Protección del trabajo local sin guardar: **no pisa** un archivo local que difiera del
+remoto salvo con `--force`. Sin `--force` no aborta el pull entero — baja lo que es
+seguro, deja afuera los conflictivos y sale con código 1 para que decidas (mirá
+`shilo diff <archivo>`). Los archivos que sólo existen localmente nunca se tocan: el
+pull no borra. `--dry-run` muestra el impacto sobre tu disco (nuevo / sobrescribe /
+se conserva), no el árbol remoto crudo.
+
+También bloquea nombres que intenten escribir fuera de la carpeta destino (path
+traversal) y saltea binarios con aviso (volverían corruptos). Espejo de `push`:
+`--project` pisa a `.shilo.json`. Con `shilo init --pull` se ata y baja en un solo paso.
+
 ### Servidor alternativo
 
 ```bash
@@ -78,3 +152,20 @@ contraseña.
   `ensurePath`/`commit`) + recorrido de árbol (`.shiloignore`) + detección de binarios.
 - **Fase 3 — push** *(hecho)*: `shilo init` + `shilo push` (crea/actualiza + commit,
   detección de cambios, `.shiloignore`, `--dry-run`).
+- **Fase 4 — pull** *(hecho)*: `shilo pull` (recorrido del árbol remoto con pool,
+  guarda anti path-traversal, salto de binarios, colisiones, binding `.shilo.json`,
+  `--dry-run`). Cierra el ciclo `pull → trabajar local → push`.
+- **Fase 5 — colaboración asíncrona** *(hecho)*: `status` (comparación barata local vs
+  remoto + exit code 2), `log` (historial por proyecto o archivo), `diff` (comparación
+  de contenido + exit code 1), atribución de autor en `push --dry-run`, `pull` que
+  resuelve conflictos por archivo en vez de abortar, `lastSync` en `.shilo.json` y
+  `push --card <id>` para cruzar commits con un tablero externo (Metrónomo).
+
+## Exit codes
+
+| Comando  | Código | Significado                                  |
+| -------- | ------ | -------------------------------------------- |
+| `status` | 2      | El remoto tiene cambios que no tenés.        |
+| `diff`   | 1      | Hay diferencias entre local y remoto.        |
+| `pull`   | 1      | Quedaron conflictos sin bajar (o fallas).    |
+| cualquiera | 1    | Error.                                       |

package/bin/shilo.js

@@ -17,7 +17,11 @@ ${ui.c.bold('Comandos:')}
   whoami             Muestra la sesión activa.
   logout             Cierra sesión (borra credenciales locales).
   init [carpeta]     Ata una carpeta a un repo de Shilo (--project <uuid>).
+  status [carpeta]   Compara local vs remoto sin bajar nada (¿estoy desactualizado?).
   push [carpeta]     Sube una carpeta al repo de Shilo (crea/actualiza + commit).
+  pull [carpeta]     Baja un repo de Shilo a una carpeta local (deja .shilo.json).
+  log [archivo]      Historial de commits del proyecto o de un archivo.
+  diff [archivo]     Diferencias entre tu copia local y la remota.
   help               Muestra esta ayuda.
 
 ${ui.c.bold('Opciones de login:')}
@@ -30,16 +34,44 @@ ${ui.c.bold('Opciones de init:')}
   --project <uuid>   Id del proyecto de Shilo (requerido).
   --token <pat>      Token de acceso personal (evita el "login" previo).
   --push             Sube la carpeta apenas queda atada.
+  --pull             Baja la carpeta apenas queda atada.
   --base-url <url>   Servidor Shilo.
   --force            No verifica acceso ni pregunta antes de sobrescribir.
 
+${ui.c.bold('Opciones de status:')}
+  --project <uuid>   Proyecto a comparar (pisa el .shilo.json de la carpeta).
+  --short            Sólo las rutas, sin autor ni fecha.
+  --json             Salida JSON (para scripts).
+  --base-url <url>   Servidor Shilo.
+  ${ui.c.dim('Exit code 2 = el remoto tiene cambios que no tenés.')}
+
 ${ui.c.bold('Opciones de push:')}
   --project <uuid>   Proyecto destino (pisa el .shilo.json de la carpeta).
   -m, --message <m>  Mensaje del commit.
-  --dry-run          Muestra qué haría, sin subir nada.
+  --card <id>        Id de tarjeta/tablero; se agrega al mensaje como [card: id].
+  --dry-run          Muestra qué haría (y quién tocó cada archivo), sin subir nada.
   --yes              No pide confirmación.
   --base-url <url>   Servidor Shilo.
 
+${ui.c.bold('Opciones de pull:')}
+  --project <uuid>   Proyecto origen (pisa el .shilo.json de la carpeta).
+  --dry-run          Muestra qué cambiaría localmente, sin bajar nada.
+  --yes              No pide confirmación.
+  --force            Sobrescribe también los archivos locales que difieren.
+  --base-url <url>   Servidor Shilo.
+
+${ui.c.bold('Opciones de log:')}
+  -n <N>             Cuántos commits mirar (1-100, default 20).
+  --files            Lista los archivos de cada commit.
+  --json             Salida JSON.
+  --project <uuid>   Proyecto (pisa el .shilo.json de la carpeta).
+
+${ui.c.bold('Opciones de diff:')}
+  --context <n>      Líneas de contexto (0-20, default 3).
+  --stat             Sólo el resumen de líneas agregadas/quitadas.
+  --project <uuid>   Proyecto (pisa el .shilo.json de la carpeta).
+  ${ui.c.dim('Sin archivo, resume todo lo que difiere. Exit code 1 = hay diferencias.')}
+
 ${ui.c.bold('Globales:')}
   -v, --version      Versión del CLI.
   -h, --help         Ayuda.
@@ -51,6 +83,10 @@ const COMMANDS = {
   logout: () => require('../src/commands/logout'),
   init: () => require('../src/commands/init'),
   push: () => require('../src/commands/push'),
+  pull: () => require('../src/commands/pull'),
+  status: () => require('../src/commands/status'),
+  log: () => require('../src/commands/log'),
+  diff: () => require('../src/commands/diff'),
 };
 
 async function main() {
@@ -59,7 +95,10 @@ async function main() {
     // 'push' tiene que estar acá: la lista de booleanos es global, y sin
     // registrarlo `shilo init --project X --push .` se comería el `.` como
     // valor de --push, perdiendo el positional de la carpeta.
-    booleans: ['help', 'version', 'h', 'v', 'dry-run', 'yes', 'force', 'push'],
+    booleans: [
+      'help', 'version', 'h', 'v', 'dry-run', 'yes', 'force', 'push', 'pull',
+      'json', 'short', 'stat', 'files',
+    ],
     aliases: { h: 'help', v: 'version', m: 'message' },
   });
 

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "shilo-cli",
-  "version": "0.2.0",
-  "description": "CLI para subir carpetas locales a repositorios de Shilo (login + push tipo git).",
+  "version": "0.3.1",
+  "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log y diff.",
   "keywords": [
     "shilo",
     "cli",
     "push",
+    "pull",
+    "status",
+    "diff",
+    "sync",
     "upload",
     "repositorios"
   ],

package/src/ShiloClient.js

@@ -402,6 +402,28 @@ class ShiloClient {
     return currentCreds;
   }
 
+  /**
+   * Lista el historial de commits del proyecto (más nuevo primero).
+   * `includeFiles` pide además los `commit_files` de cada commit, que es lo que
+   * permite saber quién tocó cada archivo por última vez.
+   * Devuelve `{ commits, hasMore, credentials }`.
+   */
+  async listCommits(projectId, credentials, { limit = 20, page = 1, includeFiles = false } = {}) {
+    const params = new URLSearchParams({ limit: String(limit), page: String(page) });
+    if (includeFiles) params.set('include', 'files');
+    const url = `${this.baseURL}/api/commits/${projectId}?${params.toString()}`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials);
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo listar el historial: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const commits = data && Array.isArray(data.commits) ? data.commits : [];
+    const hasMore = !!(data && data.pagination && data.pagination.hasMore);
+    return { commits, hasMore, credentials: creds };
+  }
+
   /**
    * Crea un commit con la lista de cambios de archivos (máx 100 por lote).
    * `changes`: [{ file_id, action, previous_storage_path?, new_storage_path? }].

package/src/commands/diff.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const textdiff = require('../textdiff');
+const { resolveContext } = require('../context');
+
+/**
+ * shilo diff [archivo] [--context <n>] [--stat] [--project <uuid>]
+ *
+ * Compara la versión local con la remota. Sin argumento hace un resumen de todo
+ * lo que difiere (barato: sólo listados). Con un archivo baja SOLO ese archivo y
+ * muestra el diff línea a línea.
+ *
+ * Convención de signos: el remoto es la base, lo local es el cambio. O sea
+ * `+` es lo que un push agregaría al remoto, `-` lo que borraría. Así el diff se
+ * lee igual que el push que vendría después.
+ */
+async function diff(args) {
+  const filePath = typeof args._[0] === 'string' ? args._[0] : null;
+  const ctx = resolveContext({ ...args, _: [] });
+  if (!ctx.ok) return ctx.code;
+
+  const { dir, projectId, baseURL, cfg, client, mgr } = ctx;
+
+  const context = parseContext(args.context);
+  if (context === null) {
+    ui.error('El valor de --context debe ser un entero entre 0 y 20.');
+    return 1;
+  }
+
+  return filePath
+    ? diffOne({ dir, projectId, cfg, client, mgr, filePath, context, stat: !!args.stat })
+    : diffAll({ dir, projectId, baseURL, cfg, client, mgr });
+}
+
+/**
+ * Diff de un archivo puntual: una sola descarga.
+ */
+async function diffOne({ dir, projectId, cfg, client, mgr, filePath, context, stat }) {
+  const repoPath = sync.toRepoPath(dir, filePath);
+  if (!repoPath) {
+    ui.error(`La ruta queda fuera de la carpeta: ${filePath}`);
+    return 1;
+  }
+
+  const absPath = require('path').resolve(dir, repoPath);
+  const localText = sync.readLocalText(absPath);
+
+  let remoteText = null;
+  let exists = false;
+  try {
+    const creds = await mgr.valid();
+    const meta = await client.getFileMeta(projectId, repoPath, creds);
+    exists = meta.exists && meta.file && meta.file.type !== 'folder';
+    if (exists) {
+      if (!sync.isTextMime(meta.file.mime_type)) {
+        ui.error(`"${repoPath}" no es texto en el remoto (${meta.file.mime_type}): no se puede diffear.`);
+        return 1;
+      }
+      const read = await client.readFile(projectId, repoPath, await mgr.valid());
+      remoteText = read.file && read.file.content != null ? read.file.content : '';
+    }
+  } catch (e) {
+    ui.error(`No se pudo leer "${repoPath}" del remoto: ${e.message}`);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  if (!exists && localText === null) {
+    ui.error(`"${repoPath}" no existe ni local ni remotamente.`);
+    return 1;
+  }
+  if (!exists) {
+    ui.info(`${ui.c.green('+')} ${repoPath} ${ui.c.dim('(sólo local: un push lo crearía)')}`);
+    remoteText = '';
+  }
+  if (localText === null) {
+    ui.info(`${ui.c.red('-')} ${repoPath} ${ui.c.dim('(sólo remoto: un pull lo bajaría)')}`);
+  }
+
+  const result = textdiff.diffText(remoteText || '', localText === null ? '' : localText, { context });
+
+  if (result.identical) {
+    ui.success(`Sin diferencias: ${repoPath}`);
+    return 0;
+  }
+
+  ui.info('');
+  ui.info(`${ui.c.dim('--- remoto')}  ${ui.c.dim(repoPath)}`);
+  ui.info(`${ui.c.dim('+++ local')}   ${ui.c.dim(absPath)}`);
+
+  if (stat || result.tooBig) {
+    for (const line of textdiff.renderDiff({ ...result, hunks: [] }, { paint: ui.c })) {
+      ui.info(line);
+    }
+    if (!result.tooBig) {
+      ui.info(`  ${ui.c.green(`+${result.added}`)} / ${ui.c.red(`-${result.removed}`)} líneas`);
+    }
+    return 1;
+  }
+
+  for (const line of textdiff.renderDiff(result, { paint: ui.c })) ui.info(line);
+  ui.info('');
+  ui.info(`  ${ui.c.green(`+${result.added}`)} / ${ui.c.red(`-${result.removed}`)} líneas`);
+  // Exit 1 = "hay diferencias", como `git diff --exit-code`.
+  return 1;
+}
+
+/**
+ * Resumen de diferencias de toda la carpeta, sin bajar contenido.
+ */
+async function diffAll({ dir, projectId, baseURL, cfg, client, mgr }) {
+  ui.info(`Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — comparando ...`);
+
+  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);
+  }
+
+  const cmp = sync.compareTrees(local.files, tree.files);
+  const total = cmp.onlyLocal.length + cmp.onlyRemote.length + cmp.differing.length;
+
+  ui.info('');
+  if (total === 0) {
+    ui.success('Sin diferencias de tamaño ni de archivos entre local y remoto.');
+    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 cmp.differing) {
+    const delta = item.local.size - item.remote.size;
+    const sign = delta > 0 ? `+${delta}` : String(delta);
+    ui.info(`  ${ui.c.yellow('~')} ${item.repoPath} ${ui.c.dim(`(${sign} bytes)`)}`);
+  }
+
+  ui.info('');
+  ui.info(ui.c.dim(`${total} archivo(s) con diferencias. Usá "shilo diff <archivo>" para ver el detalle.`));
+  return 1;
+}
+
+function parseContext(raw) {
+  if (raw === undefined || raw === null || raw === '') return 3;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0 || n > 20) return null;
+  return n;
+}
+
+module.exports = diff;

package/src/commands/init.js

@@ -23,7 +23,7 @@ const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
  *
  * Con --token guarda las credenciales antes de verificar, de modo que el
  * comando de una línea que se copia desde la web funcione sin "login" previo.
- * Con --push, sube la carpeta al terminar.
+ * Con --push, sube la carpeta al terminar; con --pull, la baja.
  */
 async function init(args) {
   const dir = path.resolve(args._[0] || '.');
@@ -103,6 +103,11 @@ async function init(args) {
     return require('./push')({ ...args, _: [dir], yes: true });
   }
 
+  if (args.pull) {
+    // Espejo de --push: el usuario ya confirmó al pasar --pull.
+    return require('./pull')({ ...args, _: [dir], yes: true });
+  }
+
   ui.info(`Ahora podés subir con: ${ui.c.bold('shilo push')}`);
   return 0;
 }

package/src/commands/log.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const { resolveContext } = require('../context');
+
+const DEFAULT_LIMIT = 20;
+
+/**
+ * shilo log [archivo] [-n <N>] [--project <uuid>] [--files] [--json]
+ *
+ * Historial de commits del proyecto, o sólo los que tocaron `archivo`.
+ * Sólo lectura: no toca ni el disco ni el remoto.
+ *
+ * Ojo con el filtro por archivo: el backend pagina commits, no cambios, así que
+ * filtramos del lado del cliente sobre las últimas páginas. Si un archivo no se
+ * toca hace mucho, puede necesitar un `-n` más grande para aparecer; el comando
+ * avisa cuando se queda sin historial explorado.
+ */
+async function log(args) {
+  // El positional de `log` es un archivo, no una carpeta: el contexto se
+  // resuelve siempre sobre el directorio actual.
+  const filePath = typeof args._[0] === 'string' ? args._[0] : null;
+  const ctx = resolveContext({ ...args, _: [] });
+  if (!ctx.ok) return ctx.code;
+
+  const { dir, projectId, baseURL, cfg, client, mgr } = ctx;
+  const asJson = !!args.json;
+  const showFiles = !!args.files || !!filePath;
+
+  const limit = parseLimit(args.n || args.number, DEFAULT_LIMIT);
+  if (limit === null) {
+    ui.error('El valor de -n debe ser un entero entre 1 y 100.');
+    return 1;
+  }
+
+  // Si se pidió un archivo puntual, primero resolvemos su id en el remoto.
+  let targetId = null;
+  let repoPath = null;
+  if (filePath) {
+    repoPath = sync.toRepoPath(dir, filePath);
+    if (!repoPath) {
+      ui.error(`La ruta queda fuera de la carpeta: ${filePath}`);
+      return 1;
+    }
+    try {
+      const creds = await mgr.valid();
+      const meta = await client.getFileMeta(projectId, repoPath, creds);
+      if (!meta.exists || !meta.file) {
+        ui.error(`No existe en el remoto: ${repoPath}`);
+        return 1;
+      }
+      targetId = meta.file.id;
+    } catch (e) {
+      ui.error(`No se pudo resolver "${repoPath}": ${e.message}`);
+      return 1;
+    } finally {
+      config.persistCredsIfChanged(cfg, mgr.current);
+    }
+  }
+
+  let result;
+  try {
+    const creds = await mgr.valid();
+    result = await client.listCommits(projectId, creds, {
+      limit,
+      includeFiles: showFiles,
+    });
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  let commits = result.commits;
+  if (targetId) {
+    commits = commits.filter((c) => (c.files || []).some((cf) => cf.files && cf.files.id === targetId));
+  }
+
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        {
+          projectId,
+          path: repoPath,
+          commits: commits.map((c) => ({
+            hash: c.hash,
+            message: c.message,
+            author: sync.describeAuthor(c.users),
+            date: c.created_at,
+            files: (c.files || []).map((cf) => ({
+              name: cf.files ? cf.files.name : null,
+              action: cf.action,
+            })),
+          })),
+          hasMore: result.hasMore,
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  const scope = repoPath ? `de ${ui.c.bold(repoPath)}` : 'del proyecto';
+  ui.info(`Historial ${scope} — ${ui.c.cyan(baseURL)}`);
+  ui.info('');
+
+  if (commits.length === 0) {
+    ui.info(
+      repoPath
+        ? `Sin commits para "${repoPath}" en los últimos ${limit} del proyecto.`
+        : 'El proyecto todavía no tiene commits.'
+    );
+    if (result.hasMore) ui.info(ui.c.dim(`Probá con -n mayor (hay más historial).`));
+    return 0;
+  }
+
+  for (const commit of commits) {
+    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}`);
+    if (showFiles && Array.isArray(commit.files) && commit.files.length > 0) {
+      const shown = repoPath
+        ? commit.files.filter((cf) => cf.files && cf.files.id === targetId)
+        : commit.files;
+      for (const cf of shown) {
+        ui.info(`    ${ui.c.dim(`${actionMark(cf.action)} ${cf.files ? cf.files.name : '?'}`)}`);
+      }
+    }
+    ui.info('');
+  }
+
+  if (result.hasMore) {
+    ui.info(ui.c.dim(`(mostrando los últimos ${limit} commits del proyecto; hay más)`));
+  }
+  return 0;
+}
+
+function actionMark(action) {
+  if (action === 'added') return '+';
+  if (action === 'deleted') return '-';
+  return '~';
+}
+
+function parseLimit(raw, fallback) {
+  if (raw === undefined || raw === null || raw === '') return fallback;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > 100) return null;
+  return n;
+}
+
+module.exports = log;