@jpkme/diff-review 0.1.3 → 0.1.5

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

package/lib/extract.mjs

@@ -0,0 +1,111 @@
+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";
+
+export function flattenFiles(report) {
+  return Array.isArray(report?.files) ? report.files : [];
+}
+
+export function extractBranchDiff({ repo, branch, base = "develop" }) {
+  if (!branch) throw new Error("Falta el branch a revisar.");
+
+  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("\t");
+      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 || undefined,
+      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: 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: 8_000,
+        maxTotalChars: 12_000,
+      }),
+    },
+    files,
+    groups: [],
+    blocks: [],
+    findings: [],
+    skipped: [],
+  };
+}
+
+export function writeSkeleton(outPath, skeleton) {
+  const resolved = resolve(outPath);
+  mkdirSync(dirname(resolved), { recursive: true });
+  writeFileSync(resolved, JSON.stringify(skeleton, null, 2), "utf8");
+  return resolved;
+}

package/lib/git.mjs

@@ -0,0 +1,202 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export 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`).
+ */
+export 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;
+  }
+}
+
+export function git(repo, args, { maxBuffer = 64 * 1024 * 1024 } = {}) {
+  return execFileSync("git", args, {
+    cwd: repo,
+    encoding: "utf8",
+    maxBuffer,
+    windowsHide: true,
+  });
+}
+
+export function slug(s) {
+  return String(s)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/(^-|-$)/g, "");
+}
+
+export function resolveRev(repo, ref) {
+  return git(repo, ["rev-parse", ref]).trim();
+}
+
+export function branchTips(repo, branch, base) {
+  return {
+    branchSha: resolveRev(repo, branch),
+    baseSha: resolveRev(repo, base),
+  };
+}
+
+export function fingerprint(branchSha, baseSha) {
+  const a = shortSha(branchSha);
+  const b = shortSha(baseSha);
+  if (!a || !b) return null;
+  return `${a}-${b}`;
+}
+
+/** File/URL id: short tip of the reviewed branch + short tip of the base. */
+export function reportId(branchSha, baseSha) {
+  const id = fingerprint(branchSha, baseSha);
+  if (!id) throw new Error("Faltan SHAs de los tips para el id del reporte.");
+  return id;
+}
+
+function shortSha(sha, n = 10) {
+  const hex = String(sha || "").toLowerCase().replace(/[^a-f0-9]/g, "");
+  return hex.length >= 7 ? hex.slice(0, n) : "";
+}
+
+export 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 [];
+  }
+}
+
+const FILE_LINE_CACHE = new Map();
+const 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);
+  }
+}
+
+export 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;
+}
+
+export function listBranches(repo) {
+  const raw = git(repo, [
+    "for-each-ref",
+    "--sort=-committerdate",
+    "--format=%(refname:short)",
+    "refs/heads",
+    "refs/remotes",
+  ]);
+  const names = raw
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((name) => name.replace(/^origin\//, ""))
+    .filter((name) => name !== "HEAD" && !name.endsWith("/HEAD"));
+
+  // Dedup conservando el orden de for-each-ref (más reciente primero).
+  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");
+  const defaultBase = bases.includes("develop")
+    ? "develop"
+    : bases.includes("main")
+      ? "main"
+      : bases[0] || "develop";
+
+  return { branches: unique, current, defaultBase };
+}
+
+/** URL del remote (origin, o el primero disponible). Vacío si no hay. */
+export function getRemoteUrl(repo, preferred = "origin") {
+  try {
+    const url = git(repo, ["remote", "get-url", preferred]).trim();
+    if (url) return url;
+  } catch {
+    /* sin origin */
+  }
+  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 "";
+  }
+}

package/lib/git.test.mjs

@@ -0,0 +1,29 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { fingerprint, reportId, tryResolveGitRoot } from "./git.mjs";
+
+const branch = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+const base = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+test("reportId is short branch tip then base tip, hyphenated", () => {
+  assert.equal(reportId(branch, base), "aaaaaaaaaa-bbbbbbbbbb");
+  assert.equal(fingerprint(branch, base), "aaaaaaaaaa-bbbbbbbbbb");
+});
+
+test("reportId rejects missing shas", () => {
+  assert.equal(fingerprint("", base), null);
+  assert.throws(() => reportId("", base), /Faltan SHAs/);
+});
+
+test("tryResolveGitRoot finds repo from subdirectory", () => {
+  const root = tryResolveGitRoot(join(repoRoot, "lib"));
+  assert.ok(root);
+  assert.match(root.replace(/\\/g, "/"), /diff-review$/i);
+});
+
+test("tryResolveGitRoot returns null outside a repo", () => {
+  assert.equal(tryResolveGitRoot(dirname(repoRoot)), null);
+});

package/lib/json-payload.mjs

@@ -0,0 +1,31 @@
+function tryParseJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+/** Extrae un objeto JSON del texto del modelo (fences, prosa alrededor, envelope). */
+export 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.");
+}