shilo-cli 0.3.2 → 0.6.0

package/src/textguard.js

@@ -1,19 +1,39 @@
 'use strict';
 
 /**
- * Validación de nombres y detección de binarios para el push.
+ * Validación de nombres y clasificación de contenido para el push.
  *
- * Shilo sólo acepta contenido de texto (el endpoint path-based sube el body
- * como utf8, así que un binario se corrompería) y restringe los nombres de
- * archivo/carpeta a un charset acotado. Aquí filtramos ambos casos ANTES de
- * tocar la red, para poder avisar y saltar.
+ * Hasta la Etapa 2 del PLAN_MOTOR_SHILO, Shilo sólo aceptaba texto: el endpoint
+ * por ruta sube el body como utf8, así que un binario se corrompía. Ahora los
+ * binarios SÍ se suben, pero por otro camino —`POST /api/files/:id/direct`, con
+ * URL firmada, sin pasar por JSON— y por eso este módulo ya no los rechaza:
+ * los CLASIFICA, para que el push sepa por dónde mandar cada archivo.
+ *
+ * Lo que sigue rechazando, y no cambió: los nombres que rompen una ruta o no son
+ * portables, y los archivos que superan el techo de tamaño. El escaneo de
+ * secretos también se queda; vive en `secrets.js` y sólo corre sobre texto,
+ * porque buscar patrones de credenciales en un JPEG es ruido.
+ *
+ * Espejo de `backend/utils/binary.js`: mismas constantes, misma heurística. Son
+ * dos paquetes sin dependencia entre sí (el CLI se publica solo y no tiene un
+ * solo `dependencies`), así que la duplicación es deliberada — pero si cambia
+ * una tiene que cambiar la otra, o un archivo se clasifica de un modo en el
+ * cliente y de otro en el servidor.
  */
 
-// Charset permitido por el backend (ver backend/api/files/[projectId].js):
-//   ^[a-zA-Z0-9._\-\[\]()@]+$  y ni "." ni ".." ni separadores de ruta.
-const VALID_NAME = /^[a-zA-Z0-9._\-[\]()@]+$/;
+// Espejo de `backend/utils/filenames.js`: lista negra, no lista blanca. El
+// backend acepta cualquier carácter que no rompa una ruta —acentos, espacios,
+// kanji—, así que restringir acá sólo hacía que un repo perfectamente válido
+// se subiera incompleto.
+const ILLEGAL_CHARS = /[<>:"/\\|?*]/;
+
+// Nombres de dispositivo reservados de Windows, con o sin extensión.
+const WIN_RESERVED = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.|$)/i;
+
 const MAX_NAME_LEN = 255;
-const MAX_FILE_BYTES = 26214400; // 25 MB, igual que el backend
+// Espejo de MAX_FILE_BYTES en backend/utils/binary.js y del CHECK
+// `file_size_valid` de la migración 014. Los tres son el mismo número.
+const MAX_FILE_BYTES = 52428800; // 50 MB, igual que el backend
 const MAX_DEPTH = 10; // profundidad máxima de carpetas
 
 // Extensiones típicamente binarias: pre-filtro rápido antes de leer bytes.
@@ -32,27 +52,49 @@ const BINARY_EXTENSIONS = new Set([
   'ttf', 'otf', 'woff', 'woff2', 'eot', 'psd', 'ai', 'sketch', 'db', 'sqlite',
 ]);
 
+// Los bytes de control se chequean por código y no con un rango en el regex:
+// escritos literalmente el archivo deja de ser texto plano para git y grep, y
+// escritos como escape son invisibles al leer el código. Un bucle es explícito.
+function hasControlChars(str) {
+  for (let i = 0; i < str.length; i += 1) {
+    const code = str.charCodeAt(i);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
 /**
  * Valida un nombre individual (archivo o carpeta) contra las reglas de Shilo.
+ * Espejo de `validateFileName` en `backend/utils/filenames.js`: mismos rechazos,
+ * mismo orden, con el mensaje en el idioma del CLI.
  * Devuelve `{ ok: true }` o `{ ok: false, reason }`.
  */
-function validateName(name) {
+function validateName(rawName) {
+  // El backend guarda el nombre normalizado y sin espacios al borde: validamos
+  // sobre esa misma forma para no aceptar acá algo que allá se transforma.
+  const name = typeof rawName === 'string' ? rawName.normalize('NFC').trim() : '';
+
   if (!name || name === '.' || name === '..') {
     return { ok: false, reason: 'nombre reservado (. o ..)' };
   }
   if (name.length > MAX_NAME_LEN) {
     return { ok: false, reason: `nombre demasiado largo (>${MAX_NAME_LEN})` };
   }
-  if (name.includes('/') || name.includes('\\')) {
-    return { ok: false, reason: 'contiene separador de ruta' };
-  }
-  if (!VALID_NAME.test(name)) {
+  if (ILLEGAL_CHARS.test(name) || hasControlChars(name)) {
     return {
       ok: false,
-      reason: 'caracteres no permitidos (usá solo A-Z a-z 0-9 . _ - [ ] ( ) @ y sin espacios/acentos)',
+      reason: 'caracteres no permitidos (/ \\ : * ? " < > | o bytes de control)',
     };
   }
-  return { ok: true };
+  if (WIN_RESERVED.test(name)) {
+    return { ok: false, reason: 'nombre de dispositivo reservado en Windows (CON, NUL, COM1…)' };
+  }
+  // Windows descarta el punto final al crear el archivo, así que "informe." y
+  // "informe" terminarían siendo el mismo archivo en disco.
+  if (name.endsWith('.')) {
+    return { ok: false, reason: 'no puede terminar en punto' };
+  }
+  return { ok: true, name };
 }
 
 /**
@@ -98,27 +140,64 @@ function looksBinary(buffer, sample = 8000) {
 }
 
 /**
- * Decide si un archivo es texto apto para subir. Recibe el nombre (para la
- * extensión) y el Buffer con su contenido. Devuelve:
- *   { isText: true, content }                 -> subir `content` (utf8)
- *   { isText: false, reason }                 -> saltar con aviso
+ * Mapa mínimo extensión -> mime. El backend vuelve a adivinar por su cuenta con
+ * `mime-types`, pero mandar el tipo desde acá es mejor: el cliente vio los bytes
+ * y el servidor, en una subida directa, sólo ve el nombre.
+ */
+const MIME_BY_EXT = {
+  png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif',
+  webp: 'image/webp', avif: 'image/avif', bmp: 'image/bmp', ico: 'image/x-icon',
+  tiff: 'image/tiff', tif: 'image/tiff', heic: 'image/heic',
+  pdf: 'application/pdf', zip: 'application/zip', gz: 'application/gzip',
+  tar: 'application/x-tar', mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg',
+  mp4: 'video/mp4', mov: 'video/quicktime', webm: 'video/webm',
+  ttf: 'font/ttf', otf: 'font/otf', woff: 'font/woff', woff2: 'font/woff2',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+};
+
+/** Tipo de contenido de un binario. `octet-stream` cuando no se sabe. */
+function binaryMimeType(name) {
+  return MIME_BY_EXT[extensionOf(name)] || 'application/octet-stream';
+}
+
+/**
+ * Clasifica el contenido de un archivo. Recibe el nombre (para la extensión) y
+ * el Buffer con su contenido. Devuelve:
+ *   { isText: true,  content }                 -> sube por JSON (batch)
+ *   { isText: false, isBinary: true, buffer, mimeType }
+ *                                              -> sube por URL firmada (direct)
+ *   { isText: false, isBinary: false, reason }  -> saltar con aviso
+ *
+ * El techo de tamaño se comprueba PRIMERO, antes de decidir texto o binario: un
+ * archivo demasiado grande se saltea sea lo que sea, y ponerlo después haría que
+ * el mensaje dijera "binario" cuando el problema es el tamaño.
  */
 function classifyContent(name, buffer) {
-  const ext = extensionOf(name);
-  if (ext && BINARY_EXTENSIONS.has(ext)) {
-    return { isText: false, reason: `extensión binaria .${ext}` };
-  }
-  if (looksBinary(buffer)) {
-    return { isText: false, reason: 'contenido binario (bytes no imprimibles)' };
-  }
   if (buffer.length > MAX_FILE_BYTES) {
-    return { isText: false, reason: `supera 25 MB (${buffer.length} bytes)` };
+    return {
+      isText: false,
+      isBinary: false,
+      reason: `supera ${MAX_FILE_BYTES / (1024 * 1024)} MB (${buffer.length} bytes)`,
+    };
   }
-  return { isText: true, content: buffer.toString('utf8') };
+
+  const ext = extensionOf(name);
+  if ((ext && BINARY_EXTENSIONS.has(ext)) || looksBinary(buffer)) {
+    return { isText: false, isBinary: true, buffer, mimeType: binaryMimeType(name) };
+  }
+
+  return { isText: true, isBinary: false, content: buffer.toString('utf8') };
 }
 
 module.exports = {
-  VALID_NAME,
+  ILLEGAL_CHARS,
+  WIN_RESERVED,
+  hasControlChars,
   MAX_NAME_LEN,
   MAX_FILE_BYTES,
   MAX_DEPTH,
@@ -127,5 +206,7 @@ module.exports = {
   validatePath,
   looksBinary,
   classifyContent,
+  binaryMimeType,
+  MIME_BY_EXT,
   extensionOf,
 };

package/src/token.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Resolución del token de acceso personal (PAT).
+ *
+ * Un PAT pasado como `--token abc123` queda en el historial del shell, en la
+ * lista de procesos (`ps` lo muestra a cualquier usuario de la máquina) y en
+ * los logs de CI. Por eso se aceptan dos formas más discretas:
+ *
+ *   --token -            lee el token de stdin  (`cat pat.txt | shilo login --token -`)
+ *   SHILO_TOKEN=<pat>    variable de entorno    (lo natural en CI)
+ *
+ * La forma inline sigue funcionando —es la que se copia desde la web— pero
+ * avisa una vez.
+ */
+
+const STDIN_SENTINEL = '-';
+
+/** Lee stdin completo (hasta EOF) y devuelve la primera línea no vacía. */
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      reject(new Error('--token - espera el token por stdin, pero la entrada es una terminal.'));
+      return;
+    }
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+}
+
+function firstLine(text) {
+  for (const line of String(text).split(/\r?\n/)) {
+    const t = line.trim();
+    if (t) return t;
+  }
+  return '';
+}
+
+/**
+ * Devuelve `{ token, source }` con source ∈ 'flag' | 'stdin' | 'env' | null.
+ * Lanza si `--token -` no encuentra nada que leer.
+ */
+async function resolveToken(args) {
+  const raw = typeof args.token === 'string' ? args.token.trim() : '';
+
+  if (raw === STDIN_SENTINEL) {
+    const token = firstLine(await readStdin());
+    if (!token) throw new Error('No llegó ningún token por stdin.');
+    return { token, source: 'stdin' };
+  }
+
+  if (raw) return { token: raw, source: 'flag' };
+
+  const env = (process.env.SHILO_TOKEN || '').trim();
+  if (env) return { token: env, source: 'env' };
+
+  return { token: '', source: null };
+}
+
+/** Aviso (una sola línea) cuando el token viajó de la forma más expuesta. */
+function warnIfExposed(source, ui) {
+  if (source !== 'flag') return;
+  ui.warn('El token quedó en el historial del shell y en la lista de procesos.');
+  ui.info(ui.c.dim('Alternativas: SHILO_TOKEN=<pat> o `cat pat.txt | shilo login --token -`.'));
+}
+
+module.exports = { resolveToken, warnIfExposed, readStdin, firstLine, STDIN_SENTINEL };

package/src/ui.js

@@ -33,4 +33,64 @@ function error(msg) {
   console.error(`${c.red('✗')} ${msg}`);
 }
 
-module.exports = { c, info, success, warn, error };
+/** ¿La salida es una terminal interactiva? (redirigida a archivo/CI: no) */
+const isTTY = !!process.stdout.isTTY;
+
+function formatEta(secs) {
+  if (!Number.isFinite(secs) || secs < 0) return '';
+  if (secs < 60) return `${Math.max(1, Math.round(secs))}s`;
+  const mins = Math.floor(secs / 60);
+  const rest = Math.round(secs % 60);
+  return `${mins}m ${rest}s`;
+}
+
+/**
+ * Contador de progreso de una sola línea.
+ *
+ * En una terminal reescribe la misma línea con porcentaje y ETA; sin TTY no
+ * dibuja nada (una barra con `\r` en un log de CI es ruido ilegible) y en su
+ * lugar `line()` emite una línea por ítem. Así el mismo código sirve para el
+ * uso interactivo y para el registro.
+ *
+ * El repintado se limita a ~10 fps: con cientos de archivos, escribir en cada
+ * uno cuesta más que el trabajo que reporta.
+ */
+function progress(total, label = '') {
+  const start = Date.now();
+  let lastLen = 0;
+  let lastDraw = 0;
+
+  return {
+    tty: isTTY,
+    update(done) {
+      if (!isTTY || total <= 0) return;
+      const now = Date.now();
+      if (done < total && now - lastDraw < 100) return;
+      lastDraw = now;
+
+      const pct = Math.round((done / total) * 100);
+      let eta = '';
+      if (done > 0 && done < total) {
+        const elapsed = (now - start) / 1000;
+        const left = formatEta((elapsed / done) * (total - done));
+        if (left) eta = `, faltan ~${left}`;
+      }
+      const line = `  ${label} ${done}/${total} (${pct}%${eta})`;
+      const pad = Math.max(0, lastLen - line.length);
+      process.stdout.write(`\r${c.dim(line)}${' '.repeat(pad)}`);
+      lastLen = line.length;
+    },
+    /** Borra la línea de progreso para que el mensaje siguiente arranque limpio. */
+    clear() {
+      if (!isTTY || lastLen === 0) return;
+      process.stdout.write(`\r${' '.repeat(lastLen)}\r`);
+      lastLen = 0;
+    },
+    /** Línea por ítem: sólo cuando no hay barra que la pisaría. */
+    line(msg) {
+      if (!isTTY) console.log(msg);
+    },
+  };
+}
+
+module.exports = { c, info, success, warn, error, isTTY, progress, formatEta };

package/src/walk.js

@@ -4,7 +4,13 @@
  * Recorrido de un directorio local para el push.
  *
  * Responsabilidades (todo offline, sin red):
- *   - aplicar ignores por defecto (.git, node_modules, etc.) + `.shiloignore`;
+ *   - aplicar ignores por defecto (.git, node_modules, etc.) + `.gitignore` +
+ *     `.shiloignore`, incluyendo los anidados de cada subcarpeta;
+ *   - podar repositorios git detectados por su FORMA (HEAD + objects/ + refs/),
+ *     no por el nombre `.git`: un `.git-ORIGINAL-BACKUP/` trae todo el historial
+ *     y renombrarlo no lo vuelve inocuo;
+ *   - descartar nombres reservados de Windows (`nul`, `con`, `com1`…), que en
+ *     esa plataforma son dispositivos y no archivos;
  *   - descartar nombres inválidos para Shilo (poda subárboles con carpeta inválida);
  *   - respetar la profundidad máxima de carpetas;
  *   - NO leer el contenido completo (eso lo hace el push al clasificar binarios),
@@ -16,7 +22,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { validateName, MAX_DEPTH } = require('./textguard');
+const { validateName, MAX_DEPTH, WIN_RESERVED } = require('./textguard');
 
 // Ignores por defecto (nombres de carpeta/archivo, a cualquier profundidad).
 const DEFAULT_IGNORES = [
@@ -30,11 +36,40 @@ const DEFAULT_IGNORES = [
   '.vercel/',
 ];
 
+// Archivos de ignores que se leen en cada directorio, en orden de precedencia:
+// `.shiloignore` va último para poder re-incluir con `!` algo que git ignora.
+const IGNORE_FILES = ['.gitignore', '.shiloignore'];
+
+// `WIN_RESERVED` (CON, NUL, COM1…) vive en textguard porque el backend también
+// los rechaza. Acá se usan además para PODAR: abrir `nul` no devuelve un archivo
+// sino el dispositivo nulo (`readFileSync` da vacío, `statSync` es inconsistente),
+// así que se saltean en toda plataforma y no sólo en Windows.
+
+/**
+ * ¿Este directorio es un repositorio git (bare o no), sin importar cómo se llame?
+ * Un `.git-ORIGINAL-BACKUP/`, `.git.bak/` o un submódulo tienen la misma forma.
+ */
+function looksLikeGitDir(absDir) {
+  try {
+    return (
+      fs.existsSync(path.join(absDir, 'HEAD')) &&
+      fs.existsSync(path.join(absDir, 'objects')) &&
+      fs.existsSync(path.join(absDir, 'refs'))
+    );
+  } catch (_) {
+    return false;
+  }
+}
+
 /**
  * Compila una línea de patrón estilo .gitignore (subconjunto práctico) a una
- * regla { negate, dirOnly, anchored, re }.
+ * regla { negate, dirOnly, anchored, base, re }.
+ *
+ * `base` es el prefijo de ruta (POSIX, con `/` final) del directorio donde vive
+ * el archivo de ignores: una regla de `public/.gitignore` sólo aplica bajo
+ * `public/`.
  */
-function compileRule(raw) {
+function compileRule(raw, base = '') {
   let line = raw.replace(/\r$/, '');
   // Ignorar comentarios y líneas vacías.
   if (!line.trim() || line.trim().startsWith('#')) return null;
@@ -63,8 +98,10 @@ function compileRule(raw) {
     anchored = true;
   }
 
-  const re = globToRegExp(line);
-  return { negate, dirOnly, anchored, re };
+  // Los anclados se comparan contra la ruta completa, así que llevan el base
+  // incorporado; los de basename se filtran por `base` en el matcher.
+  const re = globToRegExp(anchored ? base + line : line);
+  return { negate, dirOnly, anchored, base, re };
 }
 
 function globToRegExp(glob) {
@@ -97,12 +134,14 @@ function globToRegExp(glob) {
  */
 function makeMatcher(rules) {
   return function isIgnored(relPath, isDir) {
-    const base = relPath.split('/').pop();
+    const name = relPath.split('/').pop();
     let ignored = false;
     for (const rule of rules) {
       if (!rule) continue;
       if (rule.dirOnly && !isDir) continue;
-      const target = rule.anchored ? relPath : base;
+      // Una regla de un ignore anidado sólo alcanza a su propio subárbol.
+      if (rule.base && !relPath.startsWith(rule.base)) continue;
+      const target = rule.anchored ? relPath : name;
       if (rule.re.test(target)) {
         ignored = !rule.negate;
       }
@@ -112,47 +151,86 @@ function makeMatcher(rules) {
 }
 
 /**
- * Lee y compila reglas de un `.shiloignore` en la raíz (si existe), combinadas
- * con los ignores por defecto.
+ * Compila las reglas de los archivos de ignores presentes en `absDir`.
+ * `relBase` es la ruta POSIX del directorio relativa a la raíz ('' para la raíz).
  */
-function loadIgnoreRules(rootDir, extraLines = []) {
-  const lines = [...DEFAULT_IGNORES, ...extraLines];
-  const ignorePath = path.join(rootDir, '.shiloignore');
-  if (fs.existsSync(ignorePath)) {
+function loadDirRules(absDir, relBase = '') {
+  const base = relBase ? `${relBase}/` : '';
+  const rules = [];
+  for (const fileName of IGNORE_FILES) {
+    const ignorePath = path.join(absDir, fileName);
+    let text;
     try {
-      const text = fs.readFileSync(ignorePath, 'utf8');
-      lines.push(...text.split('\n'));
+      if (!fs.existsSync(ignorePath)) continue;
+      // Sin sacar el BOM (Notepad, PowerShell) el primer patrón del archivo se
+      // compila con un caracter invisible al frente y nunca matchea.
+      text = fs.readFileSync(ignorePath, 'utf8').replace(/^/, '');
     } catch (_) {
-      /* si no se puede leer, seguimos con los defaults */
+      continue; // si no se puede leer, seguimos con lo que haya
+    }
+    for (const line of text.split('\n')) {
+      const rule = compileRule(line, base);
+      if (rule) rules.push(rule);
     }
   }
-  return lines.map(compileRule).filter(Boolean);
+  return rules;
+}
+
+/**
+ * Reglas de la raíz: defaults + `.gitignore` + `.shiloignore` + extras.
+ * Se mantiene exportada porque es la forma de inspeccionar qué se va a ignorar
+ * sin recorrer nada.
+ */
+function loadIgnoreRules(rootDir, extraLines = []) {
+  const rules = [];
+  for (const line of DEFAULT_IGNORES) {
+    const rule = compileRule(line);
+    if (rule) rules.push(rule);
+  }
+  rules.push(...loadDirRules(rootDir, ''));
+  for (const line of extraLines) {
+    const rule = compileRule(line);
+    if (rule) rules.push(rule);
+  }
+  return rules;
 }
 
 /**
  * Recorre `rootDir` y devuelve:
  *   {
- *     files:   [{ relPath, absPath, size }],  // candidatos válidos a subir
- *     skipped: [{ relPath, reason }],         // descartados (nombre/profundidad)
+ *     files:   [{ relPath, absPath, size }],       // candidatos válidos a subir
+ *     skipped: [{ relPath, reason, code }],        // descartados
  *     ignored: <número de entradas ignoradas por reglas>
+ *     gitDirs: [<rutas de repos git podados>]
  *   }
  *
  * No sigue symlinks (se reportan como skipped).
  */
 function walk(rootDir, { extraIgnore = [] } = {}) {
-  const rules = loadIgnoreRules(rootDir, extraIgnore);
-  const isIgnored = makeMatcher(rules);
+  const rootRules = loadIgnoreRules(rootDir, extraIgnore);
 
   const files = [];
   const skipped = [];
+  const gitDirs = [];
   let ignored = 0;
 
-  function recurse(absDir, relBase, folderDepth) {
+  function recurse(absDir, relBase, folderDepth, inheritedRules) {
+    // Los ignores de este directorio se suman a los heredados y valen sólo de
+    // acá para abajo: por eso se copia el array en vez de mutarlo.
+    const rules = relBase
+      ? inheritedRules.concat(loadDirRules(absDir, relBase))
+      : inheritedRules;
+    const isIgnored = makeMatcher(rules);
+
     let entries;
     try {
       entries = fs.readdirSync(absDir, { withFileTypes: true });
     } catch (err) {
-      skipped.push({ relPath: relBase || '.', reason: `no se pudo leer: ${err.message}` });
+      skipped.push({
+        relPath: relBase || '.',
+        reason: `no se pudo leer: ${err.message}`,
+        code: 'unreadable',
+      });
       return;
     }
 
@@ -160,12 +238,24 @@ function walk(rootDir, { extraIgnore = [] } = {}) {
     entries.sort((a, b) => a.name.localeCompare(b.name));
 
     for (const entry of entries) {
-      const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+      // El nombre lógico (el que viaja al repo) se normaliza igual que en el
+      // backend —NFC y sin espacios al borde— porque es la forma que se guarda:
+      // macOS devuelve NFD, y sin esto "café.md" local y "café.md" remoto no se
+      // reconocen como el mismo archivo. `absPath` usa el nombre tal cual lo dio
+      // el SO, que es el que hay que abrir.
+      const logicalName = entry.name.normalize('NFC').trim();
+      const relPath = relBase ? `${relBase}/${logicalName}` : logicalName;
       const absPath = path.join(absDir, entry.name);
       const isDir = entry.isDirectory();
 
       if (entry.isSymbolicLink()) {
-        skipped.push({ relPath, reason: 'symlink (no soportado)' });
+        skipped.push({ relPath, reason: 'symlink (no soportado)', code: 'symlink' });
+        continue;
+      }
+
+      if (WIN_RESERVED.test(entry.name)) {
+        // No es un archivo real en Windows; leerlo devolvería el dispositivo nulo.
+        ignored++;
         continue;
       }
 
@@ -174,40 +264,58 @@ function walk(rootDir, { extraIgnore = [] } = {}) {
         continue;
       }
 
-      const nameCheck = validateName(entry.name);
+      if (isDir && looksLikeGitDir(absPath)) {
+        // Todo el historial del repo, incluidos secretos de commits ya purgados
+        // del árbol de trabajo. Se poda entero y se avisa una sola vez.
+        gitDirs.push(relPath);
+        continue;
+      }
+
+      const nameCheck = validateName(logicalName);
       if (!nameCheck.ok) {
-        skipped.push({ relPath, reason: nameCheck.reason });
+        skipped.push({ relPath, reason: nameCheck.reason, code: 'name' });
         continue; // si es carpeta, se poda todo el subárbol
       }
 
       if (isDir) {
         if (folderDepth + 1 > MAX_DEPTH) {
-          skipped.push({ relPath, reason: `profundidad de carpetas > ${MAX_DEPTH}` });
+          skipped.push({
+            relPath,
+            reason: `profundidad de carpetas > ${MAX_DEPTH}`,
+            code: 'depth',
+          });
           continue;
         }
-        recurse(absPath, relPath, folderDepth + 1);
+        recurse(absPath, relPath, folderDepth + 1, rules);
       } else if (entry.isFile()) {
         let size = 0;
+        let mtimeMs = 0;
         try {
-          size = fs.statSync(absPath).size;
+          const st = fs.statSync(absPath);
+          size = st.size;
+          mtimeMs = st.mtimeMs;
         } catch (_) {
           /* si falla el stat, dejamos size en 0; el push lo detecta al leer */
         }
-        files.push({ relPath, absPath, size });
+        files.push({ relPath, absPath, size, mtimeMs });
       }
       // otros tipos (fifo, socket, device) se ignoran silenciosamente
     }
   }
 
-  recurse(rootDir, '', 0);
-  return { files, skipped, ignored };
+  recurse(rootDir, '', 0, rootRules);
+  return { files, skipped, ignored, gitDirs };
 }
 
 module.exports = {
   walk,
   loadIgnoreRules,
+  loadDirRules,
   makeMatcher,
   compileRule,
   globToRegExp,
+  looksLikeGitDir,
   DEFAULT_IGNORES,
+  IGNORE_FILES,
+  WIN_RESERVED,
 };