@jpkme/diff-review 0.1.2 → 0.1.4

package/README.md

@@ -22,7 +22,23 @@ O sin instalar:
 npx @jpkme/diff-review
 ```
 
-Abre `http://127.0.0.1:5190`. Opciones: `--port`, `--host`, `--no-open`.
+### Modos
+
+Desde un **repo git**, el default es terminal-first:
+
+1. Loguea repo / branch y copia el prompt al portapapeles.
+2. Espera el JSON (`diff-report_{branchTip}-{baseTip}_YYYYMMDD-HHmmss.json`) en la raíz del repo.
+3. Valida y abre el viewer con el reporte ya importado.
+
+Si el branch actual y la base son iguales (diff vacío), abre la UI directamente para que elijas otra base o branch.
+
+Para abrir la UI primero (sin esperar el JSON):
+
+```bash
+diff-review --ui
+```
+
+Opciones: `--port`, `--host`, `--base`, `--branch`, `--no-open`.
 
 Si lo lanzás desde un repositorio git, la UI precarga esa ruta y el branch actual.
 
@@ -35,12 +51,12 @@ npm run build            # build de producción → web/build
 npm start                # mismo que el bin global
 ```
 
-## Flujo
+## Flujo (UI)
 
-1. Pegá la ruta (o URL) del repo y elegí branch / base — o lanzá `diff-review` desde el repo y se precarga solo.
+1. Pegá la ruta (o URL) del repo y elegí branch / base — o lanzá `diff-review` / `diff-review --ui` desde el repo.
 2. Copiá el prompt (o el comando de skill `/diff-review`).
-3. Corrélo en tu agente; que escriba `diff-review-output.json`.
-4. Arrastrá ese JSON a la dropzone. La UI hidrata los diffs con git.
+3. Corrélo en tu agente; que escriba `diff-report_{tips}_{stamp}.json` (también acepta el legacy `diff-review-output….json`).
+4. Arrastrá ese JSON a la dropzone (o dejá que el CLI lo importe solo). La UI hidrata los diffs con git.
 
 "Ver ejemplo" carga un reporte de muestra sin tocar un repo.
 
@@ -84,7 +100,7 @@ y minificados.
 .
 ├── bin/          # CLI (diff-review)
 ├── schema.json   # contrato del JSON que escribe el agente
-├── lib/          # git / extract (dev + tests; va embebido en el build)
+├── lib/          # git / extract / prompt (dev + tests; va en el paquete)
 └── web/          # UI SvelteKit → web/build en el paquete npm
 ```
 

package/bin/diff-review.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 /**
- * CLI: levanta la UI local (build de SvelteKit) y abre el browser.
+ * CLI híbrido C:
+ *   diff-review              → terminal: prompt + clipboard + espera JSON → abre viewer
+ *   diff-review --ui         → web-first (UI inmediata)
  *
- *   diff-review
  *   diff-review --port 5191
  *   diff-review --no-open
  */
@@ -12,6 +13,11 @@ import { existsSync } from 'node:fs';
 import { createServer } from 'node:net';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { copyTextToClipboard } from '../lib/clipboard.mjs';
+import { branchTips, getRemoteUrl, listBranches, tryResolveGitRoot } from '../lib/git.mjs';
+import { formatOutputStamp, makeOutputFilename } from '../lib/output-name.mjs';
+import { buildPrompt } from '../lib/prompt.mjs';
+import { waitForReviewOutput } from '../lib/wait-output.mjs';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const packageRoot = join(here, '..');
@@ -37,14 +43,21 @@ function resolveNodeBin() {
 }
 
 function printHelp() {
-	console.log(`diff-review — UI local para revisar un branch con tu agente.
+	console.log(`diff-review — review de branch con tu agente + UI local.
 
 Usage:
   diff-review [options]
 
+Por defecto (desde un repo git): copia el prompt, espera el JSON y abre el viewer.
+Si branch y base coinciden, abre la UI para que elijas otra combinación.
+Con --ui: abre la UI de inmediato (web-first).
+
 Options:
   -p, --port <n>   Puerto (default ${DEFAULT_PORT})
       --host <h>   Host (default ${DEFAULT_HOST})
+      --ui         Abrir la UI primero (sin esperar JSON)
+      --base <b>   Base del merge-base (default: develop / detección)
+      --branch <b> Branch a revisar (default: branch actual)
       --no-open    No abrir el navegador
   -h, --help       Esta ayuda
 
@@ -53,12 +66,23 @@ Requiere git en PATH. Los reportes viven en localStorage del navegador.
 }
 
 function parseArgs(argv) {
-	const opts = { port: DEFAULT_PORT, host: DEFAULT_HOST, open: true, help: false };
+	const opts = {
+		port: DEFAULT_PORT,
+		host: DEFAULT_HOST,
+		open: true,
+		help: false,
+		ui: false,
+		base: '',
+		branch: ''
+	};
 	for (let i = 0; i < argv.length; i++) {
 		const a = argv[i];
 		if (a === '-h' || a === '--help') opts.help = true;
 		else if (a === '--no-open') opts.open = false;
+		else if (a === '--ui') opts.ui = true;
 		else if (a === '--host') opts.host = argv[++i] || opts.host;
+		else if (a === '--base') opts.base = argv[++i] || opts.base;
+		else if (a === '--branch') opts.branch = argv[++i] || opts.branch;
 		else if (a === '-p' || a === '--port') {
 			const n = Number(argv[++i]);
 			if (!Number.isFinite(n) || n <= 0) {
@@ -105,13 +129,42 @@ function canListen(host, port) {
 	});
 }
 
-async function main() {
-	const opts = parseArgs(process.argv.slice(2));
-	if (opts.help) {
-		printHelp();
-		process.exit(0);
+/**
+ * @returns {{ repo: string, branch: string, base: string, remoteUrl?: string } | null}
+ */
+function resolveLaunchRepo(opts) {
+	const cwd = process.cwd();
+	const root = tryResolveGitRoot(cwd);
+	if (!root) return null;
+	const listed = listBranches(root);
+	const branch =
+		String(opts.branch || '').trim() ||
+		(listed.current && listed.current !== 'HEAD' ? listed.current : listed.branches[0] || '');
+	const base =
+		String(opts.base || '').trim() ||
+		(listed.branches.includes('develop') ? 'develop' : listed.defaultBase);
+	const remoteUrl = getRemoteUrl(root) || undefined;
+	return { repo: root, branch, base, remoteUrl };
+}
+
+function logRepoContext(ctx) {
+	console.log(`Repo:   ${ctx.repo}`);
+	console.log(`Branch: ${ctx.branch}  (base: ${ctx.base})`);
+}
+
+function copyPromptOrWarn(prompt) {
+	if (copyTextToClipboard(prompt)) {
+		console.log('Prompt copiado al portapapeles.');
+		return true;
 	}
+	console.log('No pude copiar al portapapeles; pegá el prompt a mano desde la UI o reintentá.');
+	return false;
+}
 
+/**
+ * @param {{ host: string, port: number, open: boolean, launchCwd: string, importFile?: string, openPath?: string }} cfg
+ */
+async function startServer(cfg) {
 	if (!existsSync(entry)) {
 		console.error(`No encontré el build en ${entry}
 Corré desde el repo: npm run build
@@ -119,23 +172,23 @@ O reinstalá el paquete (el tarball de npm incluye el build).`);
 		process.exit(1);
 	}
 
-	if (!(await canListen(opts.host, opts.port))) {
-		console.error(`No se pudo usar ${opts.host}:${opts.port} (¿ocupado?). Probá --port otro.`);
+	if (!(await canListen(cfg.host, cfg.port))) {
+		console.error(`No se pudo usar ${cfg.host}:${cfg.port} (¿ocupado?). Probá --port otro.`);
 		process.exit(1);
 	}
 
-	const origin = `http://${opts.host}:${opts.port}`;
+	const origin = `http://${cfg.host}:${cfg.port}`;
+	const openUrl = cfg.openPath ? `${origin}${cfg.openPath}` : origin;
 	const nodeBin = resolveNodeBin();
-	/** CWD del usuario al invocar el CLI (el server corre desde web/build). */
-	const launchCwd = process.cwd();
 	const child = spawn(nodeBin, [entry], {
 		cwd: buildDir,
 		env: {
 			...process.env,
-			HOST: opts.host,
-			PORT: String(opts.port),
+			HOST: cfg.host,
+			PORT: String(cfg.port),
 			ORIGIN: origin,
-			DIFF_REVIEW_LAUNCH_CWD: launchCwd
+			DIFF_REVIEW_LAUNCH_CWD: cfg.launchCwd,
+			...(cfg.importFile ? { DIFF_REVIEW_IMPORT_FILE: cfg.importFile } : {})
 		},
 		stdio: ['ignore', 'pipe', 'inherit'],
 		windowsHide: false
@@ -152,7 +205,7 @@ O reinstalá el paquete (el tarball de npm incluye el build).`);
 				if (!ready) {
 					ready = true;
 					console.log(`diff-review listo en ${terminalLink(origin)} — Ctrl+C para salir.`);
-					if (opts.open) openBrowser(origin);
+					if (cfg.open) openBrowser(openUrl);
 				}
 				continue;
 			}
@@ -175,4 +228,119 @@ O reinstalá el paquete (el tarball de npm incluye el build).`);
 	process.on('SIGTERM', stop);
 }
 
-main();
+async function main() {
+	const opts = parseArgs(process.argv.slice(2));
+	if (opts.help) {
+		printHelp();
+		process.exit(0);
+	}
+
+	const launchCwd = process.cwd();
+	const ctx = resolveLaunchRepo(opts);
+	const outputStamp = formatOutputStamp();
+	/** @type {string} */
+	let outputFilename = makeOutputFilename({ stamp: outputStamp });
+	if (ctx) {
+		try {
+			const tips = branchTips(ctx.repo, ctx.branch, ctx.base);
+			outputFilename = makeOutputFilename({
+				branchSha: tips.branchSha,
+				baseSha: tips.baseSha,
+				stamp: outputStamp
+			});
+		} catch (err) {
+			console.warn(
+				'No pude resolver tips para el nombre del JSON:',
+				err instanceof Error ? err.message : err
+			);
+		}
+	}
+
+	/** Si branch===base el three-dot está vacío: forzar UI para elegir. */
+	let openUi = opts.ui;
+	let skipPromptCopy = false;
+	if (!openUi && ctx && ctx.branch && ctx.branch === ctx.base) {
+		console.log(
+			`Branch y base son iguales (${ctx.branch}): el diff estaría vacío.\nAbro la UI para que elijas otra base o branch.`
+		);
+		openUi = true;
+		skipPromptCopy = true;
+	}
+
+	if (openUi) {
+		if (ctx) {
+			logRepoContext(ctx);
+			if (!skipPromptCopy) {
+				const prompt = buildPrompt(
+					{
+						source: 'local',
+						repo: ctx.repo,
+						branch: ctx.branch,
+						base: ctx.base,
+						remoteUrl: ctx.remoteUrl
+					},
+					{ outputFilename }
+				);
+				copyPromptOrWarn(prompt);
+			}
+		} else {
+			console.log('Sin repo git en el CWD — la UI arranca vacía.');
+		}
+		await startServer({
+			host: opts.host,
+			port: opts.port,
+			open: opts.open,
+			launchCwd,
+			openPath:
+				ctx && !skipPromptCopy
+					? `/?notify=prompt&out=${encodeURIComponent(outputFilename)}`
+					: '/'
+		});
+		return;
+	}
+
+	// Flujo terminal por defecto
+	if (!ctx) {
+		console.error(
+			'No hay un repositorio git en el directorio actual.\nUsá --ui para abrir la interfaz, o corré diff-review desde un repo.'
+		);
+		process.exit(1);
+	}
+
+	logRepoContext(ctx);
+	console.log(`Salida: ${outputFilename}`);
+	const prompt = buildPrompt(
+		{
+			source: 'local',
+			repo: ctx.repo,
+			branch: ctx.branch,
+			base: ctx.base,
+			remoteUrl: ctx.remoteUrl
+		},
+		{ outputFilename }
+	);
+	copyPromptOrWarn(prompt);
+	console.log(`Esperando ${outputFilename} en la raíz del repo… (Ctrl+C para cancelar)`);
+
+	const result = await waitForReviewOutput(ctx.repo, outputFilename, {
+		onInvalid: (errors) => {
+			console.log(`JSON encontrado pero inválido (${errors.length} error(es)). Esperando corrección…`);
+			for (const e of errors.slice(0, 5)) console.log(`  · ${e}`);
+		}
+	});
+
+	console.log('JSON OK. Abriendo viewer…');
+	await startServer({
+		host: opts.host,
+		port: opts.port,
+		open: opts.open,
+		launchCwd: ctx.repo,
+		importFile: result.path,
+		openPath: '/?import=1'
+	});
+}
+
+main().catch((err) => {
+	console.error(err?.message || err);
+	process.exit(1);
+});

package/lib/clipboard.mjs

@@ -0,0 +1,29 @@
+import { spawnSync } from "node:child_process";
+
+/** Copia texto al portapapeles del SO. Devuelve true si parece haber funcionado. */
+export function copyTextToClipboard(text) {
+  const value = String(text ?? "");
+  try {
+    if (process.platform === "win32") {
+      const r = spawnSync("clip", [], {
+        input: value,
+        encoding: "utf8",
+        windowsHide: true,
+      });
+      return r.status === 0;
+    }
+    if (process.platform === "darwin") {
+      const r = spawnSync("pbcopy", [], { input: value, encoding: "utf8" });
+      return r.status === 0;
+    }
+    let r = spawnSync("wl-copy", [], { input: value, encoding: "utf8" });
+    if (r.status === 0) return true;
+    r = spawnSync("xclip", ["-selection", "clipboard"], {
+      input: value,
+      encoding: "utf8",
+    });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}

package/lib/config.mjs

@@ -0,0 +1,233 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const 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",
+];
+
+export const STORE_DIFF_MAX = 400_000;
+/** Pack prompts so a single CLI turn stays inside a typical Pro context window. Files are not truncated to fit. */
+export const PROMPT_BATCH_CHARS = 200_000;
+export const PROMPT_BATCH_FILES = 16;
+/** Independent judge: drop findings scored below this (Claude code-review uses 80). */
+export const JUDGE_MIN_SCORE = 80;
+export const 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`. */
+export 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;
+}
+
+export 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");
+}
+
+export function globMatch(filePath, pattern) {
+  const norm = String(filePath || "").replace(/\\/g, "/");
+  return globToRegExp(pattern).test(norm);
+}
+
+export function isIgnored(filePath, patterns) {
+  return (patterns || []).some((p) => globMatch(filePath, p));
+}
+
+export 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;
+  }
+}
+
+export 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. */
+export function collectGuidelines(
+  repo,
+  filePaths,
+  {
+    rulesFile = "REVIEW.md",
+    maxChars = 8_000,
+    maxTotalChars = 12_000,
+    maxDepth = 1,
+    skipNames = [],
+  } = {},
+) {
+  const skip = new Set(skipNames);
+  const names = [...new Set([rulesFile, ...GUIDELINE_FILES])].filter((name) => !skip.has(name));
+  const seen = new Set();
+  const out = [];
+  const addRel = (rel) => {
+    const norm = String(rel || "").replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!norm || seen.has(norm)) return;
+    const abs = join(repo, ...norm.split("/"));
+    const text = readIfExists(abs);
+    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;
+}
+
+export function formatGuidelines(guidelines) {
+  if (!Array.isArray(guidelines) || !guidelines.length) return "";
+  return `\nGuidelines del repo (aplicá las que correspondan a los archivos tocados; no todas valen en una review):\n${guidelines
+    .map((g) => `--- ${g.path} ---\n${g.text}`)
+    .join("\n\n")}\n`;
+}
+
+export 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,
+  };
+}
+
+/** Drop unified-diff context lines so the model mostly sees @@ / + / -. */
+export function compactDiff(diff) {
+  return String(diff || "")
+    .replace(/\r\n/g, "\n")
+    .split("\n")
+    .filter((line) => line.length > 0 && !line.startsWith(" "))
+    .join("\n");
+}
+
+export function hunkHeaders(diff, limit = 10) {
+  const out = [];
+  for (const line of String(diff || "").split("\n")) {
+    if (!line.startsWith("@@")) continue;
+    out.push(line.trim().slice(0, 140));
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+/**
+ * Model-facing diff: send the stored unified diff as-is, including context lines.
+ * Only clips if a single file exceeds `max` (safety for generated dumps that slipped ignore).
+ */
+export function modelSlice(diff, max = STORE_DIFF_MAX) {
+  const raw = String(diff || "");
+  if (raw.length <= max) {
+    return { diff: raw, modelChars: raw.length, modelTruncated: false };
+  }
+  const note = `\n\n… [el modelo no vio el resto: ${raw.length} chars en el archivo]`;
+  const clipped = raw.slice(0, Math.max(0, max - note.length));
+  return {
+    diff: clipped + note,
+    modelChars: clipped.length,
+    modelTruncated: true,
+  };
+}

package/lib/config.test.mjs

@@ -0,0 +1,73 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { collectGuidelines, compactDiff, formatGuidelines, hunkHeaders, modelSlice } from "./config.mjs";
+
+const sample = [
+  "diff --git a/src/big.ts b/src/big.ts",
+  "--- a/src/big.ts",
+  "+++ b/src/big.ts",
+  "@@ -1,3 +1,3 @@",
+  " import a from 'a';",
+  "-const oldHead = 1;",
+  "+const newHead = 1;",
+  " keep();",
+  "@@ -80,4 +80,8 @@ export function later() {",
+  "   const ctx = true;",
+  "-  return 0;",
+  "+  if (!ready) throw new Error('boom');",
+  "+  const token = auth();",
+  "+  if (!token) return null;",
+  "+  return token;",
+  " }",
+].join("\n");
+
+test("compactDiff drops context lines and keeps hunks", () => {
+  const compact = compactDiff(sample);
+  assert.equal(compact.includes(" keep();"), false);
+  assert.equal(compact.includes("@@ -80,4 +80,8 @@"), true);
+  assert.equal(compact.includes("+  if (!ready)"), true);
+});
+
+test("hunkHeaders returns @@ lines", () => {
+  assert.deepEqual(hunkHeaders(sample, 4), [
+    "@@ -1,3 +1,3 @@",
+    "@@ -80,4 +80,8 @@ export function later() {",
+  ]);
+});
+
+test("modelSlice keeps the full unified diff including context", () => {
+  const { diff, modelTruncated, modelChars } = modelSlice(sample);
+  assert.equal(modelTruncated, false);
+  assert.equal(modelChars, sample.length);
+  assert.equal(diff.includes(" keep();"), true);
+  assert.equal(diff.includes("+const newHead"), true);
+  assert.equal(diff.includes("+  if (!ready)"), true);
+});
+
+test("modelSlice only clips when a file exceeds max", () => {
+  const { diff, modelTruncated } = modelSlice(sample, 80);
+  assert.equal(modelTruncated, true);
+  assert.equal(diff.includes("el modelo no vio el resto"), true);
+});
+
+test("collectGuidelines loads root and nested CLAUDE.md", () => {
+  const root = mkdtempSync(join(tmpdir(), "diff-review-g-"));
+  try {
+    writeFileSync(join(root, "CLAUDE.md"), "root rules");
+    writeFileSync(join(root, "REVIEW.md"), "team review");
+    mkdirSync(join(root, "apps", "foo"), { recursive: true });
+    writeFileSync(join(root, "apps", "foo", "CLAUDE.md"), "nested rules");
+    const docs = collectGuidelines(root, ["apps/foo/bar.ts"]);
+    const paths = docs.map((d) => d.path);
+    assert.ok(paths.includes("CLAUDE.md"));
+    assert.ok(paths.includes("REVIEW.md"));
+    assert.ok(paths.includes("apps/foo/CLAUDE.md"));
+    assert.match(docs.find((d) => d.path === "apps/foo/CLAUDE.md").text, /nested/);
+    assert.match(formatGuidelines(docs), /apps\/foo\/CLAUDE\.md/);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});