shilo-cli 0.2.0 → 0.3.1

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