@jpkme/diff-review 0.1.3 → 0.1.4

package/lib/remote-repo.mjs

@@ -0,0 +1,182 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { git } from "./git.mjs";
+
+const CACHE_ROOT = join(tmpdir(), "diff-review-clones");
+const MAX_DEEPEN_ROUNDS = 8;
+const DEEPEN_BY = "50";
+
+export function looksLikeGitUrl(value) {
+  const v = String(value || "").trim();
+  if (!v) return false;
+  if (/^(https?:\/\/|git@|ssh:\/\/)/i.test(v)) return true;
+  if (/\.git$/i.test(v) && !/^[A-Za-z]:/.test(v) && !v.startsWith("/") && !v.startsWith("\\")) {
+    return true;
+  }
+  return false;
+}
+
+export function normalizeGitUrl(url) {
+  const raw = String(url || "").trim();
+  if (!raw) throw new Error("Indicá la URL del repositorio.");
+  if (!looksLikeGitUrl(raw)) {
+    throw new Error(
+      `"${raw}" no parece una URL git. Usá https://…, git@… o ssh://…`,
+    );
+  }
+  if (/^(file:|javascript:|data:)/i.test(raw)) {
+    throw new Error("Esquema de URL no permitido.");
+  }
+  return raw.replace(/\/$/, "");
+}
+
+function cacheDirFor(url) {
+  const key = createHash("sha1").update(url).digest("hex").slice(0, 16);
+  return join(CACHE_ROOT, key);
+}
+
+function runGit(args, { cwd, timeout = 5 * 60 * 1000 } = {}) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    windowsHide: true,
+    timeout,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+}
+
+/** Lista heads del remote sin clonar. */
+export function listRemoteBranches(url) {
+  const remote = normalizeGitUrl(url);
+  let raw;
+  try {
+    raw = runGit(["ls-remote", "--heads", remote]);
+  } catch (err) {
+    const stderr = String(/** @type {{ stderr?: string }} */ (err).stderr || err.message || err);
+    throw new Error("No se pudo listar branches del remote: " + stderr.split("\n").find(Boolean));
+  }
+
+  const branches = [
+    ...new Set(
+      raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+          const ref = line.split("\t")[1] || "";
+          return ref.replace(/^refs\/heads\//, "");
+        })
+        .filter(Boolean),
+    ),
+  ].sort((a, b) => a.localeCompare(b));
+
+  if (!branches.length) {
+    throw new Error("El remote no expone branches (refs/heads).");
+  }
+
+  const defaultBase = branches.includes("develop")
+    ? "develop"
+    : branches.includes("main")
+      ? "main"
+      : branches.includes("master")
+        ? "master"
+        : branches[0];
+
+  return { branches, current: "", defaultBase };
+}
+
+function fetchRef(repo, ref) {
+  const name = String(ref || "").trim();
+  if (!name) return;
+  try {
+    runGit(["rev-parse", "--verify", name], { cwd: repo });
+    return;
+  } catch {
+    /* falta localmente */
+  }
+  runGit(
+    ["fetch", "--depth", DEEPEN_BY, "origin", `refs/heads/${name}:refs/heads/${name}`],
+    { cwd: repo },
+  );
+}
+
+function deepenUntilMergeBase(repo, base, branch) {
+  for (let i = 0; i < MAX_DEEPEN_ROUNDS; i++) {
+    try {
+      git(repo, ["merge-base", base, branch]);
+      return;
+    } catch {
+      runGit(
+        [
+          "fetch",
+          "--deepen",
+          DEEPEN_BY,
+          "origin",
+          `refs/heads/${base}:refs/heads/${base}`,
+          `refs/heads/${branch}:refs/heads/${branch}`,
+        ],
+        { cwd: repo },
+      );
+    }
+  }
+  throw new Error(
+    `No se encontró merge-base entre "${base}" y "${branch}" (historial shallow insuficiente). Probá con más historia o usá una carpeta local.`,
+  );
+}
+
+/**
+ * Asegura un worktree local (cache en tmp) con branch y base disponibles para diff.
+ * @returns {string} ruta absoluta del clone
+ */
+export function ensureRemoteWorktree(url, branch, base = "develop") {
+  const remote = normalizeGitUrl(url);
+  const b = String(branch || "").trim();
+  const baseRef = String(base || "develop").trim() || "develop";
+  if (!b) throw new Error("Falta el branch a revisar.");
+
+  mkdirSync(CACHE_ROOT, { recursive: true });
+  const dir = cacheDirFor(remote);
+  const gitDir = join(dir, ".git");
+
+	if (!existsSync(gitDir)) {
+		if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+		try {
+			runGit(
+				[
+					"clone",
+					"--filter=blob:none",
+					"--depth",
+					DEEPEN_BY,
+					"--branch",
+					b,
+					remote,
+					dir,
+				],
+				{ timeout: 10 * 60 * 1000 },
+			);
+		} catch (err) {
+			if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+			const stderr = String(/** @type {{ stderr?: string }} */ (err).stderr || err.message || err);
+			throw new Error("No se pudo clonar el repo: " + stderr.split("\n").find(Boolean));
+		}
+	} else {
+		try {
+			runGit(["remote", "set-url", "origin", remote], { cwd: dir });
+		} catch {
+			/* remote ya ok */
+		}
+		fetchRef(dir, b);
+		try {
+			runGit(["checkout", "--force", b], { cwd: dir });
+		} catch {
+			/* detached / already on branch */
+		}
+	}
+
+  if (baseRef !== b) fetchRef(dir, baseRef);
+  deepenUntilMergeBase(dir, baseRef, b);
+  return dir;
+}

package/lib/review.mjs

@@ -0,0 +1,228 @@
+import {
+  BLOCK_OPS,
+  FINDING_CLASSES,
+  FINDING_KINDS,
+  FINDING_SEVERITIES,
+  GROUP_KINDS,
+  SKIP_REASONS,
+  WHY_SOURCES,
+} from "./validate.mjs";
+
+const MAX = {
+  intent: 700,
+  groupTitle: 100,
+  groupIntent: 300,
+  what: 240,
+  why: 240,
+  finding: 360,
+};
+
+function text(value, max) {
+  const raw = String(value ?? "").replace(/\s+/g, " ").trim();
+  return raw.length > max ? `${raw.slice(0, max - 1).trimEnd()}…` : raw;
+}
+
+function oneOf(value, allowed, fallback) {
+  const raw = String(value ?? "").trim().toLowerCase();
+  return allowed.includes(raw) ? raw : fallback;
+}
+
+/**
+ * Rango de líneas de un bloque. `L40-58` es post-imagen (lo que quedó);
+ * `-L88-95` es pre-imagen, que es la única forma de señalar líneas borradas.
+ */
+export function parseLineRange(value) {
+  const raw = String(value ?? "").trim();
+  const match = /^(-)?L?(\d+)(?:\s*[-–]\s*L?(\d+))?$/i.exec(raw);
+  if (!match) return null;
+  const start = Number(match[2]);
+  const end = match[3] ? Number(match[3]) : start;
+  return {
+    side: match[1] ? "old" : "new",
+    start: Math.min(start, end),
+    end: Math.max(start, end),
+  };
+}
+
+export function formatLineRange(range) {
+  if (!range) return "";
+  const prefix = range.side === "old" ? "-L" : "L";
+  return range.start === range.end ? `${prefix}${range.start}` : `${prefix}${range.start}-${range.end}`;
+}
+
+export function countHunks(files) {
+  let total = 0;
+  for (const file of files || []) {
+    for (const line of String(file.diff || "").split("\n")) {
+      if (line.startsWith("@@")) total += 1;
+    }
+  }
+  return total;
+}
+
+function normalizeGroups(raw) {
+  const seen = new Set();
+  const groups = [];
+  for (const item of raw || []) {
+    const id = String(item?.id || "").trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    groups.push({
+      id,
+      kind: oneOf(item.kind, GROUP_KINDS, "chore"),
+      title: text(item.title, MAX.groupTitle) || `${oneOf(item.kind, GROUP_KINDS, "chore")}: cambios`,
+      intent: text(item.intent, MAX.groupIntent),
+    });
+  }
+  return groups;
+}
+
+function normalizeBlocks(raw, { groupIds, knownPaths }) {
+  const seen = new Set();
+  const blocks = [];
+  for (const item of raw || []) {
+    const id = String(item?.id || "").trim();
+    const group = String(item?.group || "").trim();
+    const file = String(item?.file || "").trim();
+    if (!id || seen.has(id)) continue;
+    if (!groupIds.has(group)) continue;
+    if (knownPaths.size && !knownPaths.has(file)) continue;
+    const range = parseLineRange(item.lines);
+    seen.add(id);
+    blocks.push({
+      id,
+      group,
+      file,
+      lines: range ? formatLineRange(range) : text(item.lines, 24),
+      side: range?.side || "new",
+      start: range?.start ?? 0,
+      end: range?.end ?? 0,
+      op: oneOf(item.op, BLOCK_OPS, "mod"),
+      what: text(item.what, MAX.what),
+      why: text(item.why, MAX.why),
+      source: oneOf(item.source, WHY_SOURCES, "inferred"),
+    });
+  }
+  blocks.sort((a, b) => a.file.localeCompare(b.file) || a.start - b.start);
+  return blocks;
+}
+
+function findingKey(finding) {
+  return [finding.file, finding.line ?? "", finding.kind, finding.what].join("|");
+}
+
+function normalizeFindings(raw, { blockIds, knownPaths }) {
+  const seen = new Set();
+  const findings = [];
+  for (const item of raw || []) {
+    const file = String(item?.file || item?.path || "").trim();
+    const what = text(item?.what || item?.title, MAX.finding);
+    if (!file || !what) continue;
+    if (knownPaths.size && !knownPaths.has(file)) continue;
+    const cls = oneOf(item.class, FINDING_CLASSES, "risk");
+    const severity = oneOf(item.severity, FINDING_SEVERITIES, "med");
+    const block = String(item?.block || "").trim();
+    const line = Number.isFinite(Number(item?.line)) ? Number(item.line) : null;
+    const finding = {
+      id: "",
+      class: cls,
+      severity,
+      // Una mejora de calidad nunca frena un merge, diga lo que diga el modelo;
+      // un riesgo alto sí, aunque el modelo se haya olvidado de marcarlo.
+      blocking: cls === "risk" && (item?.blocking === true || severity === "high"),
+      kind: oneOf(item.kind, FINDING_KINDS, "other"),
+      file,
+      line,
+      block: blockIds.has(block) ? block : "",
+      what,
+      fix: text(item.fix || item.detail, MAX.finding),
+    };
+    const key = findingKey(finding);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    findings.push(finding);
+  }
+  const rank = { high: 0, med: 1, low: 2, nit: 3 };
+  findings.sort(
+    (a, b) =>
+      Number(b.blocking) - Number(a.blocking) ||
+      (a.class === b.class ? 0 : a.class === "risk" ? -1 : 1) ||
+      rank[a.severity] - rank[b.severity] ||
+      a.file.localeCompare(b.file),
+  );
+  findings.forEach((finding, i) => {
+    finding.id = `f${i + 1}`;
+  });
+  return findings;
+}
+
+function normalizeSkipped(raw, ignored) {
+  const byFile = new Map();
+  for (const path of ignored || []) {
+    byFile.set(String(path), { file: String(path), reason: "ignored" });
+  }
+  for (const item of raw || []) {
+    const file = String(item?.file || "").trim();
+    if (!file) continue;
+    byFile.set(file, { file, reason: oneOf(item.reason, SKIP_REASONS, "trivial") });
+  }
+  return [...byFile.values()];
+}
+
+/** Tema donde se dibuja el archivo: el que aporta más bloques, desempatando por orden de tema. */
+export function dominantGroup(blocks, path, groupOrder) {
+  const tally = new Map();
+  for (const block of blocks) {
+    if (block.file !== path) continue;
+    tally.set(block.group, (tally.get(block.group) || 0) + 1);
+  }
+  if (!tally.size) return "";
+  return [...tally.entries()].sort(
+    (a, b) => b[1] - a[1] || groupOrder.indexOf(a[0]) - groupOrder.indexOf(b[0]),
+  )[0][0];
+}
+
+/**
+ * Documento final: lo que dijo el modelo, saneado y cruzado contra los archivos
+ * reales del diff. Todo lo que no cierra se descarta acá en vez de romper la UI.
+ */
+export function buildReview({ skeleton, payload, notes = [] }) {
+  const files = skeleton.files || [];
+  const knownPaths = new Set(files.map((f) => f.path));
+
+  const groups = normalizeGroups(payload?.groups);
+  const groupIds = new Set(groups.map((g) => g.id));
+  const blocks = normalizeBlocks(payload?.blocks, { groupIds, knownPaths });
+  const blockIds = new Set(blocks.map((b) => b.id));
+  const findings = normalizeFindings(payload?.findings, { blockIds, knownPaths });
+  const skipped = normalizeSkipped(payload?.skipped, skeleton.context?.ignored);
+
+  const usedGroups = new Set(blocks.map((b) => b.group));
+  const liveGroups = groups.filter((g) => usedGroups.has(g.id));
+  const groupOrder = liveGroups.map((g) => g.id);
+
+  const skippedFiles = new Set(skipped.map((s) => s.file));
+  const orphans = files.filter((f) => !blocks.some((b) => b.file === f.path) && !skippedFiles.has(f.path));
+  if (orphans.length) {
+    notes = [...notes, `${orphans.length} archivo(s) quedaron sin explicación del modelo.`];
+  }
+
+  const decorated = files.map((file) => ({
+    ...file,
+    group: dominantGroup(blocks, file.path, groupOrder),
+  }));
+
+  return {
+    ...skeleton,
+    version: 2,
+    intent: text(payload?.intent, MAX.intent),
+    groups: liveGroups,
+    blocks,
+    findings,
+    skipped,
+    files: decorated,
+    stats: { ...skeleton.stats, hunks: countHunks(files) },
+    notes,
+    generatedAt: new Date().toISOString(),
+  };
+}

package/lib/review.test.mjs

@@ -0,0 +1,160 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  buildReview,
+  countHunks,
+  dominantGroup,
+  formatLineRange,
+  parseLineRange,
+} from "./review.mjs";
+import { decodePayload } from "./json-payload.mjs";
+import { REVIEW_SCHEMA, reviewIssues, validateAgainst } from "./validate.mjs";
+
+const skeleton = () => ({
+  branch: "feat/x",
+  baseBranch: "develop",
+  stats: { filesChanged: 2, insertions: 10, deletions: 2 },
+  context: { ignored: ["bun.lock"] },
+  files: [
+    { path: "src/a.ts", changeType: "modified", diff: "@@ -1,3 +1,5 @@\n+uno\n@@ -20,2 +22,4 @@\n+dos" },
+    { path: "src/a.test.ts", changeType: "added", diff: "@@ -0,0 +1,9 @@\n+test" },
+  ],
+});
+
+const payload = () => ({
+  intent: "Agrega el ABM de depósitos locales end-to-end para dejar de administrarlos a mano por SQL.",
+  groups: [
+    { id: "g1", kind: "feat", title: "feat(product): CRUD de depósitos", intent: "la funcionalidad" },
+    { id: "g2", kind: "test", title: "test(warehouses): cubrir el CRUD", intent: "red de seguridad" },
+  ],
+  blocks: [
+    { id: "b1", group: "g1", file: "src/a.ts", lines: "L22-25", op: "add", what: "endpoint nuevo", why: "hacía falta", source: "code" },
+    { id: "b2", group: "g1", file: "src/a.ts", lines: "L1-5", op: "mod", what: "registra el service", why: "", source: "inferred" },
+    { id: "b3", group: "g2", file: "src/a.test.ts", lines: "L1-9", op: "add", what: "tests del CRUD", why: "", source: "code" },
+  ],
+  findings: [],
+  skipped: [],
+});
+
+test("parseLineRange entiende post-imagen, pre-imagen y línea suelta", () => {
+  assert.deepEqual(parseLineRange("L40-58"), { side: "new", start: 40, end: 58 });
+  assert.deepEqual(parseLineRange("-L88-95"), { side: "old", start: 88, end: 95 });
+  assert.deepEqual(parseLineRange("L7"), { side: "new", start: 7, end: 7 });
+  assert.deepEqual(parseLineRange("12-9"), { side: "new", start: 9, end: 12 });
+  assert.equal(parseLineRange("por ahí"), null);
+});
+
+test("formatLineRange redondea el viaje de ida y vuelta", () => {
+  assert.equal(formatLineRange(parseLineRange("40-58")), "L40-58");
+  assert.equal(formatLineRange(parseLineRange("-L88")), "-L88");
+});
+
+test("countHunks cuenta las cabeceras @@", () => {
+  assert.equal(countHunks(skeleton().files), 3);
+});
+
+test("dominantGroup gana por cantidad de bloques", () => {
+  const blocks = [
+    { file: "a.ts", group: "g2" },
+    { file: "a.ts", group: "g1" },
+    { file: "a.ts", group: "g1" },
+  ];
+  assert.equal(dominantGroup(blocks, "a.ts", ["g1", "g2"]), "g1");
+  assert.equal(dominantGroup(blocks, "otro.ts", ["g1", "g2"]), "");
+});
+
+test("buildReview arma el documento y ubica cada archivo en su grupo dominante", () => {
+  const doc = buildReview({ skeleton: skeleton(), payload: payload() });
+  assert.equal(doc.version, 2);
+  assert.equal(doc.groups.length, 2);
+  assert.equal(doc.blocks.length, 3);
+  assert.equal(doc.stats.hunks, 3);
+  assert.equal(doc.files.find((f) => f.path === "src/a.ts").group, "g1");
+  assert.equal(doc.files.find((f) => f.path === "src/a.test.ts").group, "g2");
+  assert.deepEqual(doc.notes, []);
+});
+
+test("buildReview ordena los bloques por archivo y línea", () => {
+  const doc = buildReview({ skeleton: skeleton(), payload: payload() });
+  assert.deepEqual(doc.blocks.map((b) => b.id), ["b3", "b2", "b1"]);
+});
+
+test("buildReview descarta bloques que apuntan a grupos o archivos fantasma", () => {
+  const bad = payload();
+  bad.blocks.push({ id: "b9", group: "g7", file: "src/a.ts", lines: "L1", op: "mod", what: "x" });
+  bad.blocks.push({ id: "b8", group: "g1", file: "src/inventado.ts", lines: "L1", op: "mod", what: "x" });
+  const doc = buildReview({ skeleton: skeleton(), payload: bad });
+  assert.deepEqual(doc.blocks.map((b) => b.id).sort(), ["b1", "b2", "b3"]);
+});
+
+test("buildReview tira los grupos sin bloques", () => {
+  const bad = payload();
+  bad.groups.push({ id: "g3", kind: "chore", title: "sobra", intent: "" });
+  const doc = buildReview({ skeleton: skeleton(), payload: bad });
+  assert.deepEqual(doc.groups.map((g) => g.id), ["g1", "g2"]);
+});
+
+test("buildReview avisa cuando un archivo quedó sin explicar", () => {
+  const bad = payload();
+  bad.blocks = bad.blocks.filter((b) => b.file !== "src/a.test.ts");
+  const doc = buildReview({ skeleton: skeleton(), payload: bad });
+  assert.ok(doc.notes[0].includes("sin explicación"));
+});
+
+test("buildReview suma los archivos ignorados a skipped", () => {
+  const doc = buildReview({ skeleton: skeleton(), payload: payload() });
+  assert.deepEqual(doc.skipped, [{ file: "bun.lock", reason: "ignored" }]);
+});
+
+test("buildReview conserva los nit de calidad pero no los deja bloquear", () => {
+  const withFindings = payload();
+  withFindings.findings = [
+    { class: "quality", severity: "nit", blocking: true, kind: "maintainability", file: "src/a.ts", line: 3, what: "nombre confuso", fix: "renombrar" },
+    { class: "risk", severity: "high", kind: "bug", file: "src/a.ts", line: 22, block: "b1", what: "explota con null", fix: "guardar" },
+  ];
+  const doc = buildReview({ skeleton: skeleton(), payload: withFindings });
+  assert.equal(doc.findings.length, 2);
+  assert.equal(doc.findings[0].id, "f1");
+  assert.equal(doc.findings[0].kind, "bug");
+  assert.equal(doc.findings[0].blocking, true);
+  assert.equal(doc.findings[1].severity, "nit");
+  assert.equal(doc.findings[1].blocking, false);
+});
+
+test("buildReview deduplica hallazgos repetidos y limpia referencias colgadas", () => {
+  const withFindings = payload();
+  const one = { class: "risk", severity: "med", kind: "bug", file: "src/a.ts", line: 5, what: "mismo", block: "b404" };
+  withFindings.findings = [one, { ...one }];
+  const doc = buildReview({ skeleton: skeleton(), payload: withFindings });
+  assert.equal(doc.findings.length, 1);
+  assert.equal(doc.findings[0].block, "");
+});
+
+test("una respuesta JSON del modelo atraviesa decode, validación y normalización", () => {
+  const answer = JSON.stringify({
+    intent: "Hace que las búsquedas con varias palabras matcheen los tokens en cualquier orden.",
+    groups: [
+      { id: "g1", kind: "feat", title: "feat(search): matchear tokens", intent: "el cambio" },
+      { id: "g2", kind: "test", title: "test(search): cubrir tokens", intent: "red de seguridad" },
+    ],
+    blocks: [
+      { id: "b1", group: "g1", file: "src/a.ts", lines: "L22-25", op: "add", what: "tokens AND", why: "antes frase exacta", source: "commit" },
+      { id: "b2", group: "g1", file: "src/a.ts", lines: "L1-5", op: "mod", what: "registra rewriter", why: "", source: "inferred" },
+      { id: "b3", group: "g2", file: "src/a.test.ts", lines: "L1-9", op: "add", what: "tests", why: "", source: "code" },
+    ],
+    findings: [
+      { id: "f1", class: "risk", severity: "high", blocking: true, kind: "bug", file: "src/a.ts", line: 23, block: "b1", what: "AND vacío", fix: "cortar temprano" },
+      { id: "f2", class: "quality", severity: "low", blocking: false, kind: "maintainability", file: "src/a.ts", line: 3, block: "b2", what: "split repetido", fix: "extraer tokenize" },
+    ],
+    skipped: [],
+  });
+
+  const payload = decodePayload(answer);
+  assert.deepEqual(validateAgainst(REVIEW_SCHEMA, payload), []);
+  assert.deepEqual(reviewIssues(payload, ["src/a.ts", "src/a.test.ts"]), []);
+
+  const doc = buildReview({ skeleton: skeleton(), payload });
+  assert.equal(doc.groups.length, 2);
+  assert.equal(doc.blocks.length, 3);
+  assert.deepEqual(doc.notes, []);
+});