@jpkme/diff-review 0.1.10 → 0.1.13

package/web/build/server/chunks/validate-BsTKyhsq.js

@@ -0,0 +1,1073 @@
+import { mkdirSync, existsSync, writeFileSync, readFileSync, statSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join, basename, resolve } from 'node:path';
+
+//#region ../lib/fingerprint.mjs
+/**
+* Tips cortos de SHA. Sin APIs de Node: la UI lo importa para armar el nombre del JSON.
+*/
+function shortSha(sha, n = 10) {
+	const hex = String(sha || "").toLowerCase().replace(/[^a-f0-9]/g, "");
+	return hex.length >= 7 ? hex.slice(0, n) : "";
+}
+function fingerprint(branchSha, baseSha) {
+	const a = shortSha(branchSha);
+	const b = shortSha(baseSha);
+	if (!a || !b) return null;
+	return `${a}-${b}`;
+}
+//#endregion
+//#region ../lib/output-name.mjs
+/**
+* Nombre del JSON que escribe el agente.
+* Preferido: tips cortos branch/base. Legacy (con stamp o sin tips) sigue válido al importar.
+*/
+/** Prefijo del formato actual. */
+var OUTPUT_PREFIX = "diff-rev";
+/** Prefijo legacy (sin tips / con stamp). */
+var OUTPUT_PREFIX_LEGACY = "diff-review-output";
+/** Carpeta (en la raíz del repo revisado) donde va el JSON, el diff y la sesión del agente. */
+var OUTPUT_DIR = ".diff-review";
+/** Path relativo a la raíz del repo, con `/` (el que se le da al agente): `.diff-review/<nombre>`. */
+function outputRelPath(filename) {
+	return `${OUTPUT_DIR}/${String(filename || "").replace(/^.*[\\/]/, "")}`;
+}
+/** Nombre legacy fijo. */
+var OUTPUT_FILENAME_LEGACY = `${OUTPUT_PREFIX_LEGACY}.json`;
+/**
+* Válidos:
+* - diff-rev_{branchTip}_{baseTip}.json
+* - diff-report_{branchTip}-{baseTip}_YYYYMMDD-HHmmss.json (legacy)
+* - diff-review-output.json / diff-review-output-YYYYMMDD-HHmmss.json (legacy)
+*/
+var OUTPUT_FILENAME_RE = /^(?:diff-rev_[0-9a-f]{7,12}_[0-9a-f]{7,12}|diff-report_[0-9a-f]{7,12}-[0-9a-f]{7,12}_\d{8}-\d{6}|diff-review-output(?:-\d{8}-\d{6})?)\.json$/i;
+/**
+* @param {{ branchSha?: string, baseSha?: string }} [input]
+* @returns {string}
+*   con tips: diff-rev_aaaaaaaaaa_bbbbbbbbbb.json
+*   sin tips: diff-review-output.json
+*/
+function makeOutputFilename(input = {}) {
+	const opts = input instanceof Date ? {} : input || {};
+	const fp = fingerprint(opts.branchSha, opts.baseSha);
+	if (fp) {
+		const [branchTip, baseTip] = fp.split("-");
+		if (branchTip && baseTip) return `${OUTPUT_PREFIX}_${branchTip}_${baseTip}.json`;
+	}
+	return OUTPUT_FILENAME_LEGACY;
+}
+function isOutputFilename(name) {
+	return OUTPUT_FILENAME_RE.test(String(name || "").trim());
+}
+//#endregion
+//#region ../lib/config.mjs
+var DEFAULT_IGNORE = [
+	"**/package-lock.json",
+	"**/pnpm-lock.yaml",
+	"**/yarn.lock",
+	"**/bun.lock",
+	"**/bun.lockb",
+	"**/*.g.cs",
+	"**/*Snapshot.cs",
+	"**/*.Designer.cs",
+	"**/node_modules/**",
+	"**/.svelte-kit/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/*.min.js",
+	"**/*.min.css",
+	"**/CODE_REVIEW_CORRECTNESS_FINDINGS.md"
+];
+var STORE_DIFF_MAX = 4e5;
+var GUIDELINE_FILES = [
+	"REVIEW.md",
+	"CLAUDE.md",
+	"AGENTS.md"
+];
+function unquote(s) {
+	const t = String(s || "").trim();
+	if (t.startsWith("\"") && t.endsWith("\"") || t.startsWith("'") && t.endsWith("'")) return t.slice(1, -1);
+	return t;
+}
+/** Minimal YAML: `key: value` and `key:\n  - item`. */
+function parseSimpleYaml(text) {
+	const result = {};
+	let key = null;
+	for (const raw of String(text || "").split(/\r?\n/)) {
+		if (!raw.trim() || raw.trim().startsWith("#")) continue;
+		const list = raw.match(/^\s+-\s+(.*)$/);
+		if (list && key) {
+			if (!Array.isArray(result[key])) result[key] = [];
+			result[key].push(unquote(list[1]));
+			continue;
+		}
+		const kv = raw.match(/^([A-Za-z][\w]*)\s*:\s*(.*)$/);
+		if (!kv) continue;
+		key = kv[1];
+		const v = kv[2].trim();
+		result[key] = v === "" ? [] : unquote(v);
+	}
+	return result;
+}
+function globToRegExp(glob) {
+	let g = String(glob || "").replace(/\\/g, "/");
+	if (!g.includes("/")) g = `**/${g}`;
+	let s = "";
+	for (let i = 0; i < g.length; i++) {
+		const c = g[i];
+		if (c === "*" && g[i + 1] === "*") if (g[i + 2] === "/") {
+			s += "(?:.*/)?";
+			i += 2;
+		} else {
+			s += ".*";
+			i += 1;
+		}
+		else if (c === "*") s += "[^/]*";
+		else if (c === "?") s += "[^/]";
+		else if ("+()[]{}|.^$".includes(c)) s += `\\${c}`;
+		else s += c;
+	}
+	return new RegExp(`^${s}$`, "i");
+}
+function globMatch(filePath, pattern) {
+	const norm = String(filePath || "").replace(/\\/g, "/");
+	return globToRegExp(pattern).test(norm);
+}
+function isIgnored(filePath, patterns) {
+	return (patterns || []).some((p) => globMatch(filePath, p));
+}
+function isTestPath(filePath) {
+	const p = String(filePath || "").replace(/\\/g, "/");
+	return /(^|\/)(__tests__|tests?|spec)s?(\/|$)/i.test(p) || /\.(test|spec)\.[^.]+$/i.test(p);
+}
+function readIfExists(path) {
+	try {
+		return existsSync(path) ? readFileSync(path, "utf8") : null;
+	} catch {
+		return null;
+	}
+}
+function loadReviewConfig(repo) {
+	const jsonText = readIfExists(join(repo, ".diff-review.json"));
+	const yamlText = readIfExists(join(repo, ".diff-review.yml")) || readIfExists(join(repo, ".diff-review.yaml"));
+	let extra = {};
+	if (jsonText) try {
+		extra = JSON.parse(jsonText);
+	} catch {
+		extra = {};
+	}
+	else if (yamlText) extra = parseSimpleYaml(yamlText);
+	const extraIgnore = Array.isArray(extra.ignore) ? extra.ignore.map(String) : [];
+	const rulesFile = extra.rulesFile ? String(extra.rulesFile) : "REVIEW.md";
+	const rules = readIfExists(join(repo, rulesFile)) || "";
+	const model = extra.model && extra.model !== "default" ? String(extra.model) : null;
+	return {
+		ignore: [...DEFAULT_IGNORE, ...extraIgnore],
+		model,
+		rulesFile,
+		rules: rules.trim()
+	};
+}
+/** CLAUDE.md / REVIEW.md / AGENTS.md from repo root and immediate parent dirs of touched files. */
+function collectGuidelines(repo, filePaths, { rulesFile = "REVIEW.md", maxChars = 8e3, maxTotalChars = 12e3, maxDepth = 1, skipNames = [] } = {}) {
+	const skip = new Set(skipNames);
+	const names = [.../* @__PURE__ */ new Set([rulesFile, ...GUIDELINE_FILES])].filter((name) => !skip.has(name));
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const addRel = (rel) => {
+		const norm = String(rel || "").replace(/\\/g, "/").replace(/^\/+/, "");
+		if (!norm || seen.has(norm)) return;
+		const text = readIfExists(join(repo, ...norm.split("/")));
+		if (!text || !text.trim()) return;
+		seen.add(norm);
+		out.push({
+			path: norm,
+			text: text.trim()
+		});
+	};
+	for (const name of names) addRel(name);
+	const depth = Math.max(1, Number(maxDepth) || 1);
+	for (const filePath of filePaths || []) {
+		const parts = String(filePath || "").replace(/\\/g, "/").split("/").filter(Boolean);
+		const minLen = Math.max(1, parts.length - depth);
+		for (let len = parts.length - 1; len >= minLen; len--) {
+			const dir = parts.slice(0, len).join("/");
+			for (const name of names) addRel(`${dir}/${name}`);
+		}
+	}
+	let total = 0;
+	const capped = [];
+	for (const item of out) {
+		if (total >= maxTotalChars) break;
+		const room = maxTotalChars - total;
+		const slice = item.text.slice(0, Math.min(maxChars, room));
+		if (!slice) continue;
+		capped.push({
+			path: item.path,
+			text: slice
+		});
+		total += slice.length;
+	}
+	return capped;
+}
+function capDiff(diff, max = STORE_DIFF_MAX) {
+	const text = String(diff || "");
+	if (text.length <= max) return {
+		diff: text,
+		diffChars: text.length,
+		truncated: false
+	};
+	return {
+		diff: `${text.slice(0, max)}\n\n… [diff recortado: se guardan ${max} de ${text.length} caracteres]`,
+		diffChars: text.length,
+		truncated: true
+	};
+}
+//#endregion
+//#region ../lib/git.mjs
+function assertGitRepo(repo) {
+	const raw = String(repo || "").trim();
+	if (!raw) throw new Error("Indicá la ruta absoluta de un repositorio git.");
+	if (!/[\\/]/.test(raw) && !/^[A-Za-z]:/.test(raw)) throw new Error(`"${raw}" no es una ruta. Pegá la ruta absoluta del repo (ej. C:\\tienda-argenta\\tienda-argenta-2).`);
+	const resolved = resolve(raw);
+	if (!resolved || resolved === ".") throw new Error("Indicá la ruta absoluta de un repositorio git.");
+	if (!existsSync(resolved)) throw new Error(`No existe la carpeta: ${resolved}`);
+	if (!existsSync(join(resolved, ".git"))) throw new Error(`No es un repositorio git (falta .git): ${resolved}`);
+	return resolved;
+}
+/**
+* Si `cwd` está dentro de un repo git, devuelve la raíz absoluta; si no, null.
+* Acepta subcarpetas (usa `git rev-parse --show-toplevel`).
+*/
+function tryResolveGitRoot(cwd) {
+	const raw = String(cwd || "").trim();
+	if (!raw) return null;
+	const dir = resolve(raw);
+	if (!existsSync(dir)) return null;
+	try {
+		const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+			cwd: dir,
+			encoding: "utf8",
+			windowsHide: true,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return root ? resolve(root) : null;
+	} catch {
+		return null;
+	}
+}
+function git(repo, args, { maxBuffer = 64 * 1024 * 1024 } = {}) {
+	return execFileSync("git", args, {
+		cwd: repo,
+		encoding: "utf8",
+		maxBuffer,
+		windowsHide: true
+	});
+}
+function resolveRev(repo, ref) {
+	return git(repo, ["rev-parse", ref]).trim();
+}
+function branchTips(repo, branch, base) {
+	return {
+		branchSha: resolveRev(repo, branch),
+		baseSha: resolveRev(repo, base)
+	};
+}
+function commitLog(repo, mergeBase, branch, limit = 25) {
+	try {
+		return git(repo, [
+			"log",
+			"--oneline",
+			"--no-merges",
+			"-n",
+			String(limit),
+			`${mergeBase}..${branch}`
+		]).trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+var FILE_LINE_CACHE = /* @__PURE__ */ new Map();
+var FILE_LINE_CACHE_MAX = 48;
+function rememberFileLines(key, lines) {
+	if (FILE_LINE_CACHE.has(key)) FILE_LINE_CACHE.delete(key);
+	FILE_LINE_CACHE.set(key, lines);
+	while (FILE_LINE_CACHE.size > FILE_LINE_CACHE_MAX) {
+		const oldest = FILE_LINE_CACHE.keys().next().value;
+		FILE_LINE_CACHE.delete(oldest);
+	}
+}
+function showFileLines(repo, rev, path) {
+	const resolved = assertGitRepo(repo);
+	const safeRev = String(rev || "").trim();
+	const safePath = String(path || "").replace(/\\/g, "/").trim();
+	if (!safeRev || !/^[A-Za-z0-9._/\-]+$/.test(safeRev)) throw new Error("Rev inválido.");
+	if (!safePath || safePath.startsWith("/") || safePath.includes("..") || safePath.includes("\0")) throw new Error("Ruta inválida.");
+	const key = `${resolved}\0${safeRev}\0${safePath}`;
+	if (FILE_LINE_CACHE.has(key)) return FILE_LINE_CACHE.get(key);
+	let text;
+	try {
+		text = git(resolved, ["show", `${safeRev}:${safePath}`]);
+	} catch {
+		rememberFileLines(key, null);
+		return null;
+	}
+	if (text.includes("\0")) {
+		rememberFileLines(key, null);
+		return null;
+	}
+	const raw = text.replace(/\r\n/g, "\n");
+	const lines = raw.endsWith("\n") ? raw.slice(0, -1).split("\n") : raw.split("\n");
+	rememberFileLines(key, lines);
+	return lines;
+}
+function listBranches(repo) {
+	const names = git(repo, [
+		"for-each-ref",
+		"--sort=-committerdate",
+		"--format=%(refname:short)",
+		"refs/heads",
+		"refs/remotes"
+	]).split("\n").map((s) => s.trim()).filter(Boolean).map((name) => name.replace(/^origin\//, "")).filter((name) => name !== "HEAD" && !name.endsWith("/HEAD"));
+	const unique = [...new Set(names)];
+	const current = git(repo, [
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]).trim();
+	const bases = unique.filter((n) => n === "develop" || n === "main" || n === "master");
+	return {
+		branches: unique,
+		current,
+		defaultBase: bases.includes("develop") ? "develop" : bases.includes("main") ? "main" : bases[0] || "develop"
+	};
+}
+/** URL del remote (origin, o el primero disponible). Vacío si no hay. */
+function getRemoteUrl(repo, preferred = "origin") {
+	try {
+		const url = git(repo, [
+			"remote",
+			"get-url",
+			preferred
+		]).trim();
+		if (url) return url;
+	} catch {}
+	try {
+		const remotes = git(repo, ["remote"]).split("\n").map((s) => s.trim()).filter(Boolean);
+		if (!remotes.length) return "";
+		return git(repo, [
+			"remote",
+			"get-url",
+			remotes[0]
+		]).trim();
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region ../lib/review-dir.mjs
+/**
+* Carpeta `.diff-review/` en la raíz del repo revisado: el JSON del reporte, el diff con el que se hizo y la sesión
+* del agente, todo con el mismo nombre base (`diff-rev_<branchTip>_<baseTip>`). Se ignora sola con su propio
+* `.gitignore`, así no deja cambios en archivos trackeados del repo.
+*
+* Los JSON viejos en la raíz del repo se siguen encontrando (`locateReviewFile`).
+*/
+/** @typedef {{ agentId: string, sessionId: string, model?: string, updatedAt?: string }} SessionRef */
+function reviewDir(repoRoot) {
+	return join(repoRoot, OUTPUT_DIR);
+}
+/** Crea `.diff-review/` (con su `.gitignore`) si no existe. */
+function ensureReviewDir(repoRoot) {
+	const dir = reviewDir(repoRoot);
+	mkdirSync(dir, { recursive: true });
+	const ignore = join(dir, ".gitignore");
+	if (!existsSync(ignore)) writeFileSync(ignore, "# Generado por diff-review: nada de esta carpeta va al repo.\n*\n");
+	return dir;
+}
+/** `diff-rev_a_b.json` → `{ json, diff, session }` dentro de `.diff-review/`. */
+function companionPaths(repoRoot, filename) {
+	const name = basename(String(filename || ""));
+	const stem = name.replace(/\.json$/i, "");
+	const dir = reviewDir(repoRoot);
+	return {
+		json: join(dir, name),
+		diff: join(dir, `${stem}.diff`),
+		session: join(dir, `${stem}.session.json`)
+	};
+}
+/** Dónde está el JSON de la review: `.diff-review/` primero y, si no, la raíz del repo (formato viejo). */
+function locateReviewFile(repoRoot, filename) {
+	const name = basename(String(filename || ""));
+	if (!name) return null;
+	for (const candidate of [companionPaths(repoRoot, name).json, join(repoRoot, name)]) try {
+		if (statSync(candidate).isFile()) return candidate;
+	} catch {}
+	return null;
+}
+/**
+* Guarda `git diff base...branch` junto al JSON (una vez por par de commits: el nombre ya trae los tips).
+* @returns {string | null} el path, o null si git falló
+*/
+function writeDiffCache(repoRoot, filename, { branch, base }) {
+	const { diff } = companionPaths(repoRoot, filename);
+	if (existsSync(diff)) return diff;
+	try {
+		const text = git(repoRoot, ["diff", `${base}...${branch}`]);
+		ensureReviewDir(repoRoot);
+		writeFileSync(diff, text);
+		return diff;
+	} catch {
+		return null;
+	}
+}
+/** Guarda un diff ya armado (p. ej. el que muestra la web), pisando el anterior. */
+function writeDiffText(repoRoot, filename, text) {
+	ensureReviewDir(repoRoot);
+	const { diff } = companionPaths(repoRoot, filename);
+	writeFileSync(diff, String(text ?? ""));
+	return diff;
+}
+/** @returns {string | null} texto del companion `.diff`, o null si no existe / no se pudo leer */
+function readDiffCache(repoRoot, filename) {
+	const { diff } = companionPaths(repoRoot, filename);
+	try {
+		if (!existsSync(diff)) return null;
+		return readFileSync(diff, "utf8");
+	} catch {
+		return null;
+	}
+}
+/** @param {SessionRef} ref */
+function writeSessionRef(repoRoot, filename, ref) {
+	ensureReviewDir(repoRoot);
+	const full = {
+		...ref,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeFileSync(companionPaths(repoRoot, filename).session, `${JSON.stringify(full, null, 2)}\n`);
+	return full;
+}
+//#endregion
+//#region ../lib/extract.mjs
+/**
+* Parte un `git diff` multi-archivo (texto de `writeDiffCache`) en entradas por path.
+* @param {string} text
+* @returns {Array<{ path: string, oldPath?: string, changeType: string, hunkDiff: string }>}
+*/
+function parseGitDiffFiles(text) {
+	const raw = String(text || "").replace(/\r\n/g, "\n");
+	if (!raw.trim()) return [];
+	const parts = raw.split(/^diff --git /m);
+	/** @type {Array<{ path: string, oldPath?: string, changeType: string, hunkDiff: string }>} */
+	const out = [];
+	for (const part of parts) {
+		const chunk = part.trimStart();
+		if (!chunk) continue;
+		const firstNl = chunk.indexOf("\n");
+		const paths = (firstNl === -1 ? chunk : chunk.slice(0, firstNl)).trim().match(/^a\/(.+) b\/(.+)$/);
+		if (!paths) continue;
+		let oldPath = paths[1];
+		let path = paths[2];
+		const body = firstNl === -1 ? "" : chunk.slice(firstNl + 1);
+		let changeType = "modified";
+		if (/^new file mode /m.test(body) || /^--- \/dev\/null/m.test(body)) changeType = "added";
+		else if (/^deleted file mode /m.test(body) || /^\+\+\+ \/dev\/null/m.test(body)) changeType = "deleted";
+		else if (/^rename from /m.test(body) || /^rename to /m.test(body)) {
+			changeType = "renamed";
+			const from = body.match(/^rename from (.+)$/m);
+			const to = body.match(/^rename to (.+)$/m);
+			if (from) oldPath = from[1].trim();
+			if (to) path = to[1].trim();
+		}
+		let hunkDiff = "";
+		const idx = `\n${body}`.indexOf("\n@@");
+		if (idx !== -1) hunkDiff = `\n${body}`.slice(idx + 1);
+		else if (/^Binary files /m.test(body)) hunkDiff = "";
+		out.push({
+			path,
+			oldPath: oldPath !== path ? oldPath : void 0,
+			changeType,
+			hunkDiff
+		});
+	}
+	return out;
+}
+/**
+* Stats baratos desde el texto del diff (sin volver a llamar a git).
+* @param {string} text
+*/
+function statsFromDiffText(text) {
+	let insertions = 0;
+	let deletions = 0;
+	for (const line of String(text || "").split("\n")) {
+		if (!line.length) continue;
+		if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("diff ") || line.startsWith("index ")) continue;
+		if (line.startsWith("+")) insertions += 1;
+		else if (line.startsWith("-")) deletions += 1;
+	}
+	return {
+		insertions,
+		deletions
+	};
+}
+/**
+* Tips / merge-base si git responde; si no, strings vacíos (el contenido del diff ya viene del cache).
+*/
+function tryTips(repo, branch, base) {
+	try {
+		return {
+			mergeBase: git(repo, [
+				"merge-base",
+				base,
+				branch
+			]).trim(),
+			branchSha: git(repo, ["rev-parse", branch]).trim(),
+			baseSha: git(repo, ["rev-parse", base]).trim()
+		};
+	} catch {
+		return {
+			mergeBase: "",
+			branchSha: "",
+			baseSha: ""
+		};
+	}
+}
+/**
+* Arma el mismo shape que `extractBranchDiff` a partir de un texto de `git diff` ya cacheado.
+* No vuelve a correr `git diff`.
+*/
+function skeletonFromCachedDiff(repo, branch, base, cachedDiff) {
+	const config = loadReviewConfig(repo);
+	const tips = tryTips(repo, branch, base);
+	const parsed = parseGitDiffFiles(cachedDiff);
+	const ignored = [];
+	const included = [];
+	for (const f of parsed) if (isIgnored(f.path, config.ignore)) ignored.push(f.path);
+	else included.push(f);
+	const files = included.map((f) => {
+		const capped = capDiff(f.hunkDiff);
+		return {
+			path: f.path,
+			oldPath: f.oldPath || void 0,
+			changeType: f.changeType,
+			diff: capped.diff,
+			diffChars: capped.diffChars,
+			truncated: capped.truncated,
+			modelChars: capped.diff.length,
+			group: ""
+		};
+	});
+	const { insertions, deletions } = statsFromDiffText(cachedDiff);
+	let commits = [];
+	if (tips.mergeBase) try {
+		commits = commitLog(repo, tips.mergeBase, branch);
+	} catch {
+		commits = [];
+	}
+	return {
+		version: 2,
+		repo,
+		branch,
+		baseBranch: base,
+		mergeBase: tips.mergeBase,
+		branchSha: tips.branchSha,
+		baseSha: tips.baseSha,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		intent: "",
+		stats: {
+			filesChanged: files.length,
+			filesIgnored: ignored.length,
+			filesTruncated: files.filter((f) => f.truncated).length,
+			insertions,
+			deletions
+		},
+		context: {
+			commits,
+			rules: config.rules,
+			rulesFile: config.rulesFile,
+			ignored: ignored.slice(0, 40),
+			testsTouched: files.filter((f) => isTestPath(f.path)).map((f) => f.path),
+			testsMissing: files.filter((f) => !isTestPath(f.path)).length,
+			guidelines: collectGuidelines(repo, files.map((f) => f.path), {
+				rulesFile: config.rulesFile,
+				skipNames: config.rules.trim() ? [config.rulesFile] : [],
+				maxDepth: 1,
+				maxChars: 8e3,
+				maxTotalChars: 12e3
+			})
+		},
+		files,
+		groups: [],
+		blocks: [],
+		findings: [],
+		skipped: []
+	};
+}
+/**
+* @param {{
+*   repo: string,
+*   branch: string,
+*   base?: string,
+*   cachedDiff?: string | null,
+* }} opts
+*   `cachedDiff`: texto de `git diff base...branch` ya materializado; si viene, no se vuelve a calcular el diff.
+*/
+function extractBranchDiff({ repo, branch, base = "develop", cachedDiff = null } = {}) {
+	if (!branch) throw new Error("Falta el branch a revisar.");
+	if (typeof cachedDiff === "string" && cachedDiff.length) return skeletonFromCachedDiff(repo, branch, base, cachedDiff);
+	const config = loadReviewConfig(repo);
+	const mergeBase = git(repo, [
+		"merge-base",
+		base,
+		branch
+	]).trim();
+	const branchSha = git(repo, ["rev-parse", branch]).trim();
+	const baseSha = git(repo, ["rev-parse", base]).trim();
+	const nameStatus = git(repo, [
+		"diff",
+		mergeBase,
+		branch,
+		"--name-status"
+	]).trim().split("\n").filter(Boolean).map((line) => {
+		const [status, ...rest] = line.split("	");
+		const path = rest[rest.length - 1];
+		const oldPath = rest.length > 1 ? rest[0] : null;
+		let changeType = "modified";
+		if (status.startsWith("A")) changeType = "added";
+		else if (status.startsWith("D")) changeType = "deleted";
+		else if (status.startsWith("R")) changeType = "renamed";
+		return {
+			path,
+			oldPath,
+			changeType
+		};
+	});
+	const ignored = [];
+	const included = [];
+	for (const f of nameStatus) if (isIgnored(f.path, config.ignore)) ignored.push(f.path);
+	else included.push(f);
+	const files = included.map((f) => {
+		let raw = "";
+		try {
+			raw = git(repo, [
+				"diff",
+				mergeBase,
+				branch,
+				"--",
+				f.path
+			]);
+			const idx = raw.indexOf("\n@@");
+			if (idx !== -1) raw = raw.slice(idx + 1);
+		} catch {
+			raw = "";
+		}
+		const capped = capDiff(raw);
+		return {
+			path: f.path,
+			oldPath: f.oldPath || void 0,
+			changeType: f.changeType,
+			diff: capped.diff,
+			diffChars: capped.diffChars,
+			truncated: capped.truncated,
+			modelChars: capped.diff.length,
+			group: ""
+		};
+	});
+	const shortstat = git(repo, [
+		"diff",
+		mergeBase,
+		branch,
+		"--shortstat"
+	]).trim();
+	const insMatch = shortstat.match(/(\d+) insertion/);
+	const delMatch = shortstat.match(/(\d+) deletion/);
+	return {
+		version: 2,
+		repo,
+		branch,
+		baseBranch: base,
+		mergeBase,
+		branchSha,
+		baseSha,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		intent: "",
+		stats: {
+			filesChanged: files.length,
+			filesIgnored: ignored.length,
+			filesTruncated: files.filter((f) => f.truncated).length,
+			insertions: insMatch ? Number(insMatch[1]) : 0,
+			deletions: delMatch ? Number(delMatch[1]) : 0
+		},
+		context: {
+			commits: commitLog(repo, mergeBase, branch),
+			rules: config.rules,
+			rulesFile: config.rulesFile,
+			ignored: ignored.slice(0, 40),
+			testsTouched: files.filter((f) => isTestPath(f.path)).map((f) => f.path),
+			testsMissing: files.filter((f) => !isTestPath(f.path)).length,
+			guidelines: collectGuidelines(repo, files.map((f) => f.path), {
+				rulesFile: config.rulesFile,
+				skipNames: config.rules.trim() ? [config.rulesFile] : [],
+				maxDepth: 1,
+				maxChars: 8e3,
+				maxTotalChars: 12e3
+			})
+		},
+		files,
+		groups: [],
+		blocks: [],
+		findings: [],
+		skipped: []
+	};
+}
+/**
+* Preferí el companion `.diff` en `.diff-review/` si existe; si no, `git diff` vía `extractBranchDiff`.
+* @param {{ repo: string, branch: string, base?: string, filename?: string }} opts
+*/
+function loadBranchDiff({ repo, branch, base = "develop", filename } = {}) {
+	const name = String(filename || "").trim();
+	if (name) {
+		const cached = readDiffCache(repo, name);
+		if (cached != null && cached.length) return extractBranchDiff({
+			repo,
+			branch,
+			base,
+			cachedDiff: cached
+		});
+	}
+	return extractBranchDiff({
+		repo,
+		branch,
+		base
+	});
+}
+//#endregion
+//#region ../lib/json-payload.mjs
+function tryParseJson(s) {
+	try {
+		return JSON.parse(s);
+	} catch {
+		return null;
+	}
+}
+/** Extrae un objeto JSON del texto del modelo (fences, prosa alrededor, envelope). */
+function decodePayload(text) {
+	const raw = String(text || "").trim();
+	if (!raw) throw new Error("Respuesta vacía.");
+	const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+	if (fence) {
+		const parsed = tryParseJson(fence[1].trim());
+		if (parsed && typeof parsed === "object") return parsed;
+	}
+	const direct = tryParseJson(raw);
+	if (direct && typeof direct === "object") return direct;
+	const start = raw.indexOf("{");
+	const end = raw.lastIndexOf("}");
+	if (start >= 0 && end > start) {
+		const parsed = tryParseJson(raw.slice(start, end + 1));
+		if (parsed && typeof parsed === "object") return parsed;
+	}
+	throw new Error("No se pudo interpretar la respuesta como JSON.");
+}
+//#endregion
+//#region ../lib/validate.mjs
+var GROUP_KINDS = [
+	"feat",
+	"fix",
+	"refactor",
+	"perf",
+	"test",
+	"chore",
+	"docs",
+	"infra"
+];
+var BLOCK_OPS = [
+	"add",
+	"mod",
+	"del",
+	"rename"
+];
+var WHY_SOURCES = [
+	"code",
+	"commit",
+	"pr",
+	"issue",
+	"inferred"
+];
+var FINDING_CLASSES = ["risk", "quality"];
+var FINDING_SEVERITIES = [
+	"high",
+	"med",
+	"low",
+	"nit"
+];
+var FINDING_KINDS = [
+	"bug",
+	"race",
+	"auth",
+	"security",
+	"api-break",
+	"missing-test",
+	"perf",
+	"maintainability",
+	"docs",
+	"other"
+];
+var SKIP_REASONS = [
+	"generated",
+	"lockfile",
+	"format",
+	"vendored",
+	"binary",
+	"trivial",
+	"ignored"
+];
+/** Lo que tiene que devolver el modelo en un turno. El resto lo agrega el pipeline. */
+var REVIEW_SCHEMA = {
+	type: "object",
+	required: [
+		"meta",
+		"intent",
+		"groups",
+		"blocks"
+	],
+	properties: {
+		meta: {
+			type: "object",
+			required: ["agent", "model"],
+			additionalProperties: true,
+			properties: {
+				agent: {
+					type: "string",
+					minLength: 1
+				},
+				model: {
+					type: "string",
+					minLength: 1
+				}
+			}
+		},
+		intent: {
+			type: "string",
+			minLength: 40
+		},
+		groups: {
+			type: "array",
+			minItems: 1,
+			items: {
+				type: "object",
+				required: [
+					"id",
+					"kind",
+					"title",
+					"intent"
+				],
+				additionalProperties: true,
+				properties: {
+					id: {
+						type: "string",
+						minLength: 1
+					},
+					kind: {
+						type: "string",
+						enum: GROUP_KINDS
+					},
+					title: {
+						type: "string",
+						minLength: 1
+					},
+					intent: { type: "string" }
+				}
+			}
+		},
+		blocks: {
+			type: "array",
+			minItems: 1,
+			items: {
+				type: "object",
+				required: [
+					"id",
+					"group",
+					"file",
+					"lines",
+					"op",
+					"what"
+				],
+				additionalProperties: true,
+				properties: {
+					id: {
+						type: "string",
+						minLength: 1
+					},
+					group: {
+						type: "string",
+						minLength: 1
+					},
+					file: {
+						type: "string",
+						minLength: 1
+					},
+					lines: {
+						type: "string",
+						minLength: 1
+					},
+					op: {
+						type: "string",
+						enum: BLOCK_OPS
+					},
+					what: {
+						type: "string",
+						minLength: 1
+					},
+					why: { type: "string" },
+					source: {
+						type: "string",
+						enum: WHY_SOURCES
+					}
+				}
+			}
+		},
+		findings: {
+			type: "array",
+			items: {
+				type: "object",
+				required: [
+					"class",
+					"severity",
+					"kind",
+					"file",
+					"what"
+				],
+				additionalProperties: true,
+				properties: {
+					id: { type: "string" },
+					class: {
+						type: "string",
+						enum: FINDING_CLASSES
+					},
+					severity: {
+						type: "string",
+						enum: FINDING_SEVERITIES
+					},
+					blocking: { type: "boolean" },
+					kind: {
+						type: "string",
+						enum: FINDING_KINDS
+					},
+					file: {
+						type: "string",
+						minLength: 1
+					},
+					line: { type: ["integer", "null"] },
+					block: { type: "string" },
+					what: {
+						type: "string",
+						minLength: 1
+					},
+					fix: { type: "string" }
+				}
+			}
+		},
+		skipped: {
+			type: "array",
+			items: {
+				type: "object",
+				required: ["file", "reason"],
+				additionalProperties: true,
+				properties: {
+					file: {
+						type: "string",
+						minLength: 1
+					},
+					reason: {
+						type: "string",
+						enum: SKIP_REASONS
+					}
+				}
+			}
+		}
+	}
+};
+function typeOf(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "number" && Number.isInteger(value)) return "integer";
+	return typeof value;
+}
+function typeMatches(expected, actual) {
+	const options = Array.isArray(expected) ? expected : [expected];
+	if (options.includes(actual)) return true;
+	return options.includes("number") && actual === "integer";
+}
+/** Minimal JSON Schema checker (type, required, properties, items, enum, minLength, minItems). */
+function validateAgainst(schema, data, path = "$") {
+	const errors = [];
+	if (!schema || typeof schema !== "object") return errors;
+	const actual = typeOf(data);
+	if (schema.type && !typeMatches(schema.type, actual)) {
+		errors.push(`${path}: se esperaba ${[].concat(schema.type).join("|")}, llegó ${actual}`);
+		return errors;
+	}
+	if (actual === "string" && schema.minLength && data.length < schema.minLength) errors.push(`${path}: texto demasiado corto (mínimo ${schema.minLength})`);
+	if (schema.enum && (actual === "string" || actual === "number") && !schema.enum.includes(data)) errors.push(`${path}: valor no permitido (${data}); usá uno de: ${schema.enum.join(", ")}`);
+	if (actual === "array") {
+		if (schema.minItems && data.length < schema.minItems) errors.push(`${path}: se esperaban al menos ${schema.minItems} ítems`);
+		if (schema.items) data.forEach((item, i) => errors.push(...validateAgainst(schema.items, item, `${path}[${i}]`)));
+	}
+	if (actual === "object") {
+		for (const key of schema.required || []) if (data[key] === void 0) errors.push(`${path}: falta ${key}`);
+		for (const [key, child] of Object.entries(schema.properties || {})) {
+			if (data[key] === void 0) continue;
+			errors.push(...validateAgainst(child, data[key], `${path}.${key}`));
+		}
+	}
+	return errors;
+}
+/**
+* Integridad referencial y cobertura. El schema solo mira formas; esto mira que
+* los ids cierren y que no haya quedado un archivo sin explicar, que es el
+* error que de verdad arruina la review.
+*/
+function reviewIssues(payload, knownPaths = []) {
+	const errors = [];
+	const meta = payload?.meta && typeof payload.meta === "object" ? payload.meta : {};
+	const agentName = typeof meta.agent === "string" ? meta.agent.trim() : "";
+	const modelId = typeof meta.model === "string" ? meta.model.trim() : "";
+	if (!agentName || agentName.startsWith("<")) errors.push("meta.agent es obligatorio: nombre del producto (Claude Code, Cursor, Codex, …), sin placeholder");
+	if (!modelId || modelId.startsWith("<")) errors.push("meta.model es obligatorio: id exacto del modelo, sin placeholder");
+	const groups = Array.isArray(payload?.groups) ? payload.groups : [];
+	const blocks = Array.isArray(payload?.blocks) ? payload.blocks : [];
+	const findings = Array.isArray(payload?.findings) ? payload.findings : [];
+	const skipped = Array.isArray(payload?.skipped) ? payload.skipped : [];
+	const groupIds = new Set(groups.map((g) => g.id));
+	const blockIds = new Set(blocks.map((b) => b.id));
+	const known = new Set(knownPaths);
+	const dupGroups = groups.length - groupIds.size;
+	if (dupGroups > 0) errors.push(`hay ${dupGroups} id de tema repetido`);
+	const dupBlocks = blocks.length - blockIds.size;
+	if (dupBlocks > 0) errors.push(`hay ${dupBlocks} id de bloque repetido`);
+	for (const block of blocks) {
+		if (!groupIds.has(block.group)) errors.push(`el bloque ${block.id} apunta al tema inexistente ${block.group}`);
+		if (known.size && !known.has(block.file)) errors.push(`el bloque ${block.id} apunta a un archivo que no está en el diff: ${block.file}`);
+	}
+	const usedGroups = new Set(blocks.map((b) => b.group));
+	for (const group of groups) if (!usedGroups.has(group.id)) errors.push(`el tema ${group.id} no tiene ningún bloque`);
+	for (const finding of findings) {
+		if (finding.block && !blockIds.has(finding.block)) errors.push(`el hallazgo ${finding.id || finding.what} apunta al bloque inexistente ${finding.block}`);
+		if (known.size && !known.has(finding.file)) errors.push(`el hallazgo ${finding.id || finding.what} apunta a un archivo fuera del diff: ${finding.file}`);
+	}
+	if (known.size) {
+		const covered = /* @__PURE__ */ new Set([...blocks.map((b) => b.file), ...skipped.map((s) => s.file)]);
+		const missing = [...known].filter((path) => !covered.has(path));
+		if (missing.length) errors.push(`quedaron ${missing.length} archivo(s) sin bloque ni skipped: ${missing.slice(0, 8).join(", ")}`);
+	}
+	return errors;
+}
+
+export { globMatch as A, BLOCK_OPS as B, writeDiffText as C, FINDING_CLASSES as F, GROUP_KINDS as G, OUTPUT_DIR as O, REVIEW_SCHEMA as R, SKIP_REASONS as S, WHY_SOURCES as W, assertGitRepo as a, branchTips as b, locateReviewFile as c, decodePayload as d, ensureReviewDir as e, fingerprint as f, getRemoteUrl as g, companionPaths as h, isOutputFilename as i, loadBranchDiff as j, git as k, listBranches as l, makeOutputFilename as m, FINDING_SEVERITIES as n, FINDING_KINDS as o, readDiffCache as p, extractBranchDiff as q, reviewDir as r, showFileLines as s, tryResolveGitRoot as t, loadReviewConfig as u, outputRelPath as v, writeDiffCache as w, writeSessionRef as x, validateAgainst as y, reviewIssues as z };
+//# sourceMappingURL=validate-BsTKyhsq.js.map