@jpkme/diff-review 0.1.7 → 0.1.12

package/lib/extract.mjs

@@ -2,14 +2,195 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { capDiff, collectGuidelines, isIgnored, isTestPath, loadReviewConfig } from "./config.mjs";
 import { commitLog, git } from "./git.mjs";
+import { readDiffCache } from "./review-dir.mjs";
 
 export function flattenFiles(report) {
   return Array.isArray(report?.files) ? report.files : [];
 }
 
-export function extractBranchDiff({ repo, branch, base = "develop" }) {
+/**
+ * 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 }>}
+ */
+export 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 firstLine = (firstNl === -1 ? chunk : chunk.slice(0, firstNl)).trim();
+    // `a/path b/path` (paths sin espacios raros; el formato de git suele ser este)
+    const paths = firstLine.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 : undefined,
+      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 || undefined,
+      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: 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: 8_000,
+        maxTotalChars: 12_000,
+      }),
+    },
+    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.
+ */
+export 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();
@@ -103,6 +284,21 @@ export function extractBranchDiff({ repo, branch, base = "develop" }) {
   };
 }
 
+/**
+ * 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
+ */
+export 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 });
+}
+
 export function writeSkeleton(outPath, skeleton) {
   const resolved = resolve(outPath);
   mkdirSync(dirname(resolved), { recursive: true });

package/lib/model-label.mjs

@@ -0,0 +1,263 @@
+/** Compara nombres de modelo ignorando mayúsculas, espacios y puntuación. */
+export function modelSlug(s) {
+  return String(s || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/** Parece un id técnico (claude-opus-5-5) más que un nombre legible. */
+function isSlugLike(s) {
+  const t = String(s || "").trim();
+  if (!t) return true;
+  if (/\s/.test(t)) return false;
+  if (/[A-Z]/.test(t) && /[a-z]/.test(t) && !t.includes("-")) return false; // "Sonnet", "Auto"
+  return /^[a-z0-9][a-z0-9._|-]*$/i.test(t) && (t.includes("-") || t.includes(".") || t.includes("["));
+}
+
+/**
+ * claude-opus-5-5 → Claude Opus 5.5; gpt-5.6-sol → GPT-5.6 Sol; gemini-3.8-flash → Gemini 3.8 Flash
+ * @param {string} id
+ */
+export function humanizeModelId(id) {
+  const base = String(id || "")
+    .trim()
+    .replace(/\[.*\]$/, "");
+  if (!base) return "";
+  const parts = base.split(/[-_]/).filter(Boolean);
+  const out = [];
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    const lower = p.toLowerCase();
+    if (lower === "gpt" || lower === "gpt5") {
+      out.push(lower === "gpt5" ? "GPT-5" : "GPT");
+      continue;
+    }
+    if (lower === "claude" || lower === "gemini" || lower === "grok" || lower === "composer" || lower === "muse") {
+      out.push(lower.charAt(0).toUpperCase() + lower.slice(1));
+      continue;
+    }
+    if (lower === "sonnet" || lower === "opus" || lower === "haiku" || lower === "flash" || lower === "codex") {
+      out.push(lower.charAt(0).toUpperCase() + lower.slice(1));
+      continue;
+    }
+    // 5-5 → 5.5 (versión mayor-menor)
+    if (/^\d+$/.test(p) && i + 1 < parts.length && /^\d+$/.test(parts[i + 1])) {
+      out.push(`${p}.${parts[i + 1]}`);
+      i++;
+      continue;
+    }
+    if (/^\d+(\.\d+)?$/.test(p)) {
+      out.push(p);
+      continue;
+    }
+    out.push(p.charAt(0).toUpperCase() + p.slice(1).toLowerCase());
+  }
+  return out.join(" ");
+}
+
+/**
+ * context=300k,effort=medium,fast=false → ["300k", "medium"]
+ * @param {string} raw
+ * @returns {string[]}
+ */
+export function compactModelMeta(raw) {
+  const s = String(raw || "").trim();
+  if (!s) return [];
+  /** @type {string[]} */
+  const badges = [];
+  for (const piece of s.split(",")) {
+    const part = piece.trim();
+    if (!part) continue;
+    const eq = part.indexOf("=");
+    if (eq < 0) {
+      // bare token: "1m", "1M"
+      badges.push(part);
+      continue;
+    }
+    const key = part.slice(0, eq).trim().toLowerCase();
+    const val = part.slice(eq + 1).trim();
+    if (!val || val === "false" || val === "0") continue;
+    if (key === "fast" || key === "thinking") {
+      if (val === "true" || val === "1") badges.push(key);
+      continue;
+    }
+    if (key === "context" || key === "ctx") {
+      badges.push(val);
+      continue;
+    }
+    if (key === "effort" || key === "reasoning_effort" || key === "reasoning") {
+      badges.push(val);
+      continue;
+    }
+    badges.push(val);
+  }
+  return badges;
+}
+
+/**
+ * @param {string} name
+ * @param {string} value
+ * @returns {{ title: string, badges: string[], label: string, hint?: string }}
+ */
+export function formatModelOption(name, value) {
+  const n = String(name ?? "").trim();
+  const v = String(value ?? "").trim();
+  if (!v && !n) return { title: "", badges: [], label: "" };
+  if (/^default(\[\])?$/i.test(v) && n) {
+    return { title: n, badges: [], label: n };
+  }
+
+  const bracket = /^(.+?)\[(.*)\]$/.exec(v);
+  const base = bracket ? bracket[1].trim() : v;
+  const metaRaw = bracket ? bracket[2].trim() : "";
+  let badges = compactModelMeta(metaRaw);
+
+  let title;
+  if (n && !isSlugLike(n)) {
+    title = n;
+  } else if (n && modelSlug(n) === modelSlug(base)) {
+    title = isSlugLike(n) ? humanizeModelId(base || n) : n;
+  } else if (n && isSlugLike(n)) {
+    title = humanizeModelId(base || n);
+  } else if (n) {
+    title = n;
+  } else {
+    title = humanizeModelId(base) || base || v;
+  }
+
+  // Si el título ya menciona el contexto (p. ej. "Sonnet (1M context)"), no repetir el badge "1m".
+  if (badges.length && /\(\s*\d+\s*m\b/i.test(title)) {
+    badges = badges.filter((b) => !/^\d+m$/i.test(b));
+  }
+  const titleSlug = modelSlug(title);
+  if (badges.length && titleSlug.includes(modelSlug(badges.join("")))) {
+    /* keep badges anyway for effort/fast */
+  }
+
+  const hint = badges.length ? `[ ${badges.join(", ")} ]` : undefined;
+  const label = hint ? `${title}  ·  ${hint}` : title;
+  return { title, badges, label, ...(hint ? { hint } : {}) };
+}
+
+/**
+ * Etiqueta compacta (compat / un solo string).
+ * @param {string} name
+ * @param {string} value
+ */
+export function modelOptionLabel(name, value) {
+  return formatModelOption(name, value).label || String(name || value || "").trim();
+}
+
+/**
+ * Etiqueta del ítem "usar el default del agente".
+ * @param {{ value: string, name: string } | undefined} current
+ * @param {string} [configuredOptionLabel]
+ */
+export function defaultModelOptionLabel(current, configuredOptionLabel) {
+  const name = String(current?.name ?? "").trim();
+  const value = String(current?.value ?? "").trim();
+  const generic =
+    !name ||
+    value === "default" ||
+    value === "auto" ||
+    /^default(\b|\s|\()/i.test(name) ||
+    /^auto(\b|\s|\()/i.test(name) ||
+    /\(recommended\)/i.test(name);
+
+  if (generic) {
+    const configured = String(configuredOptionLabel ?? "").trim();
+    if (configured && configured !== "Por defecto del agente") return configured;
+    return "Por defecto del agente";
+  }
+
+  const { title, hint } = formatModelOption(name, value);
+  return hint ? `Por defecto · ${title}  ·  ${hint}` : `Por defecto · ${title}`;
+}
+
+/**
+ * Orden de la lista: default (`""`) y `auto` primero, resto A→Z por label.
+ * @template {{ value: string, label?: string, title?: string }} T
+ * @param {T[]} options
+ * @returns {T[]}
+ */
+export function sortModelSelectOptions(options) {
+  const list = Array.isArray(options) ? [...options] : [];
+
+  /** @param {{ value: string, label?: string, title?: string }} o */
+  const isAuto = (o) => {
+    const v = String(o.value ?? "").toLowerCase();
+    if (v === "auto" || v.startsWith("auto[")) return true;
+    const t = String(o.title || o.label || "").trim();
+    return /^auto\b/i.test(t);
+  };
+
+  const defaults = list.filter((o) => o.value === "");
+  const autos = list.filter((o) => o.value !== "" && isAuto(o));
+  const middle = list.filter((o) => o.value !== "" && !isAuto(o));
+
+  /** @param {{ label?: string, title?: string, value: string }} a */
+  /** @param {{ label?: string, title?: string, value: string }} b */
+  const byLabel = (a, b) =>
+    String(a.label || a.title || a.value).localeCompare(String(b.label || b.title || b.value), "es", {
+      sensitivity: "base",
+      numeric: true,
+    });
+
+  autos.sort(byLabel);
+  middle.sort(byLabel);
+  return [...defaults, ...autos, ...middle];
+}
+
+/**
+ * Misma lista que la UI: default + aliases fijos + modelos ACP.
+ * Clack: `label` = título amigable, `hint` = `[ 300k, medium ]`.
+ * UI: también `title` + `badges` para chips.
+ *
+ * @param {{ models: { value: string, name: string }[], currentModel: string }} live
+ * @param {{ options: { value: string, label: string, hint?: string }[], initialValue?: string }} fixed
+ * @returns {{ options: { value: string, label: string, hint?: string, title?: string, badges?: string[] }[], initialValue: string }}
+ */
+export function buildAcpModelSelectOptions(live, fixed) {
+  const fixedOptions = fixed?.options ?? [];
+  const fallback = fixedOptions.filter((m) => m.value !== "");
+  const configuredLabel = fixedOptions.find((m) => m.value === "")?.label;
+  const current = live.models.find((m) => m.value === live.currentModel);
+  const seen = new Set(["", "default"]);
+  /** @type {{ value: string, label: string, hint?: string, title?: string, badges?: string[] }[]} */
+  const options = [
+    {
+      value: "",
+      label: defaultModelOptionLabel(current, configuredLabel),
+      title: defaultModelOptionLabel(current, configuredLabel),
+      badges: [],
+    },
+  ];
+
+  for (const m of fallback) {
+    if (seen.has(m.value)) continue;
+    seen.add(m.value);
+    options.push({
+      value: m.value,
+      label: m.label,
+      title: m.label,
+      badges: [],
+      ...(m.hint ? { hint: m.hint } : {}),
+    });
+  }
+
+  for (const m of live.models) {
+    if (seen.has(m.value)) continue;
+    seen.add(m.value);
+    const formatted = formatModelOption(m.name, m.value);
+    options.push({
+      value: m.value,
+      label: formatted.title,
+      title: formatted.title,
+      badges: formatted.badges,
+      ...(formatted.hint ? { hint: formatted.hint } : {}),
+    });
+  }
+
+  return { options: sortModelSelectOptions(options), initialValue: "" };
+}

package/lib/model-label.test.mjs

@@ -0,0 +1,77 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  buildAcpModelSelectOptions,
+  compactModelMeta,
+  formatModelOption,
+  humanizeModelId,
+  modelOptionLabel,
+} from "./model-label.mjs";
+
+test("humanizeModelId", () => {
+  assert.equal(humanizeModelId("claude-opus-5-5"), "Claude Opus 5.5");
+  assert.equal(humanizeModelId("claude-sonnet-5.5"), "Claude Sonnet 5.5");
+  assert.equal(humanizeModelId("gemini-3.8-flash"), "Gemini 3.8 Flash");
+  assert.equal(humanizeModelId("gpt-5.6-sol"), "GPT 5.6 Sol");
+});
+
+test("compactModelMeta", () => {
+  assert.deepEqual(compactModelMeta("context=300k,effort=medium,fast=false"), ["300k", "medium"]);
+  assert.deepEqual(compactModelMeta("thinking=true,context=300k,effort=high,fast=false"), [
+    "thinking",
+    "300k",
+    "high",
+  ]);
+  assert.deepEqual(compactModelMeta("1m"), ["1m"]);
+});
+
+test("formatModelOption compacto y amigable", () => {
+  const a = formatModelOption("claude-opus-5-5", "claude-opus-5-5[context=300k,effort=medium,fast=false]");
+  assert.equal(a.title, "Claude Opus 5.5");
+  assert.deepEqual(a.badges, ["300k", "medium"]);
+  assert.equal(a.label, "Claude Opus 5.5  ·  [ 300k, medium ]");
+  assert.equal(a.hint, "[ 300k, medium ]");
+
+  const b = formatModelOption("Claude Sonnet 5.5", "claude-sonnet-5.5");
+  assert.equal(b.title, "Claude Sonnet 5.5");
+  assert.deepEqual(b.badges, []);
+  assert.equal(b.label, "Claude Sonnet 5.5");
+
+  const c = formatModelOption("Sonnet (1M context)", "sonnet[1m]");
+  assert.equal(c.title, "Sonnet (1M context)");
+  assert.deepEqual(c.badges, []);
+});
+
+test("buildAcpModelSelectOptions fusiona aliases y formatea ACP", () => {
+  const { options } = buildAcpModelSelectOptions(
+    {
+      currentModel: "default",
+      models: [
+        { value: "default", name: "Default (recommended)" },
+        {
+          value: "claude-opus-5-5[context=300k,effort=medium,fast=false]",
+          name: "claude-opus-5-5",
+        },
+      ],
+    },
+    {
+      options: [
+        { value: "", label: "Por defecto (opus)" },
+        { value: "opus", label: "opus", hint: "el más capaz" },
+      ],
+    }
+  );
+  assert.equal(options[0].label, "Por defecto (opus)");
+  assert.ok(options.some((o) => o.value === "opus"));
+  const opusAcp = options.find((o) => o.value.startsWith("claude-opus-5-5"));
+  assert.equal(opusAcp?.title, "Claude Opus 5.5");
+  assert.deepEqual(opusAcp?.badges, ["300k", "medium"]);
+  assert.equal(opusAcp?.hint, "[ 300k, medium ]");
+});
+
+test("modelOptionLabel compat", () => {
+  assert.equal(
+    modelOptionLabel("grok-4.7", "grok-4.7[context=256k,fast=true]"),
+    "Grok 4.7  ·  [ 256k, fast ]"
+  );
+});

package/lib/models-cache.mjs

@@ -0,0 +1,75 @@
+/**
+ * Caché en disco de las listas de modelos ACP por agente.
+ * TTL 24h: los catálogos cambian de a poco (semanas); un día evita spawnear el CLI en cada review
+ * y sigue fresco si aparece un modelo nuevo.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+/** 24 horas. */
+export const MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+/** @returns {string} */
+export function modelsCachePath(home = homedir()) {
+  return join(home, ".diff-review", "models-cache.json");
+}
+
+/**
+ * @param {string} agentId
+ * @param {{ home?: string, now?: number, ttlMs?: number }} [opts]
+ * @returns {{ models: { value: string, name: string }[], currentModel: string, fetchedAt: string } | null}
+ */
+export function readModelsCache(agentId, opts = {}) {
+  const id = String(agentId || "").trim();
+  if (!id) return null;
+  const path = modelsCachePath(opts.home);
+  let root;
+  try {
+    root = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+  const entry = root?.agents?.[id];
+  if (!entry || !Array.isArray(entry.models)) return null;
+  const fetchedAt = Date.parse(String(entry.fetchedAt || ""));
+  if (!Number.isFinite(fetchedAt)) return null;
+  const ttl = opts.ttlMs ?? MODELS_CACHE_TTL_MS;
+  const now = opts.now ?? Date.now();
+  if (now - fetchedAt > ttl) return null;
+  return {
+    models: entry.models
+      .filter((m) => m && typeof m.value === "string")
+      .map((m) => ({ value: m.value, name: String(m.name ?? m.value) })),
+    currentModel: String(entry.currentModel ?? ""),
+    fetchedAt: new Date(fetchedAt).toISOString(),
+  };
+}
+
+/**
+ * @param {string} agentId
+ * @param {{ models: { value: string, name: string }[], currentModel?: string }} data
+ * @param {{ home?: string, now?: number }} [opts]
+ */
+export function writeModelsCache(agentId, data, opts = {}) {
+  const id = String(agentId || "").trim();
+  if (!id || !Array.isArray(data?.models) || !data.models.length) return;
+  const path = modelsCachePath(opts.home);
+  let root = { version: 1, agents: {} };
+  try {
+    if (existsSync(path)) root = { ...root, ...JSON.parse(readFileSync(path, "utf8")) };
+  } catch {
+    /* archivo nuevo */
+  }
+  if (!root.agents || typeof root.agents !== "object") root.agents = {};
+  root.agents[id] = {
+    fetchedAt: new Date(opts.now ?? Date.now()).toISOString(),
+    currentModel: String(data.currentModel ?? ""),
+    models: data.models.map((m) => ({
+      value: String(m.value),
+      name: String(m.name ?? m.value),
+    })),
+  };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(root, null, 2)}\n`);
+}

package/lib/models-cache.test.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import {
+  MODELS_CACHE_TTL_MS,
+  modelsCachePath,
+  readModelsCache,
+  writeModelsCache,
+} from "./models-cache.mjs";
+import { sortModelSelectOptions } from "./model-label.mjs";
+
+test("sortModelSelectOptions: default y auto primero, resto lexico", () => {
+  const sorted = sortModelSelectOptions([
+    { value: "zulu", label: "Zulu" },
+    { value: "auto", label: "Auto" },
+    { value: "alpha", label: "Alpha" },
+    { value: "", label: "Por defecto" },
+    { value: "bravo", label: "Bravo" },
+  ]);
+  assert.deepEqual(
+    sorted.map((o) => o.value),
+    ["", "auto", "alpha", "bravo", "zulu"]
+  );
+});
+
+test("models cache roundtrip + TTL", () => {
+  const home = mkdtempSync(join(tmpdir(), "diff-review-mc-"));
+  const now = Date.parse("2026-01-01T12:00:00.000Z");
+  writeModelsCache(
+    "claude",
+    {
+      models: [{ value: "opus", name: "Opus" }],
+      currentModel: "default",
+    },
+    { home, now }
+  );
+  assert.ok(readFileSync(modelsCachePath(home), "utf8").includes("opus"));
+
+  const hit = readModelsCache("claude", { home, now: now + 1000 });
+  assert.equal(hit?.currentModel, "default");
+  assert.equal(hit?.models[0].value, "opus");
+
+  const expired = readModelsCache("claude", {
+    home,
+    now: now + MODELS_CACHE_TTL_MS + 1,
+  });
+  assert.equal(expired, null);
+});

package/lib/output-name.mjs

@@ -11,6 +11,14 @@ export const OUTPUT_PREFIX = "diff-rev";
 export const OUTPUT_PREFIX_LEGACY = "diff-review-output";
 export const OUTPUT_PREFIX_REPORT = "diff-report";
 
+/** Carpeta (en la raíz del repo revisado) donde va el JSON, el diff y la sesión del agente. */
+export const OUTPUT_DIR = ".diff-review";
+
+/** Path relativo a la raíz del repo, con `/` (el que se le da al agente): `.diff-review/<nombre>`. */
+export function outputRelPath(filename) {
+  return `${OUTPUT_DIR}/${String(filename || "").replace(/^.*[\\/]/, "")}`;
+}
+
 /** Nombre legacy fijo. */
 export const OUTPUT_FILENAME_LEGACY = `${OUTPUT_PREFIX_LEGACY}.json`;