lody 0.62.0 → 0.63.0

package/dist/chunks/sparse-text-D7zcV2O5.js

@@ -0,0 +1,649 @@
+const FRONTMATTER_DELIMITER = "---";
+const DEFAULT_LINE_BUDGET = 1500;
+const GROUP_HEADING = /^##\s+Group:\s*(.+?)\s*$/u;
+const CHANGED_LINES = /^Changed lines:\s*(\d+)\s*$/iu;
+const COMMITS = /^Commits:\s*(.*?)\s*$/iu;
+const CODE_SPAN = /`([^`]+)`/gu;
+const CHANGE_REF = /^`(changes:\/\/[^`]+)`\s*$/u;
+const CONTEXT_REF = /^`(context:\/\/[^`]+)`\s*$/u;
+const NOTE_REF = /^\s*-\s*(?:(P0|P1|P2|QUESTION|INFO|WARNING|ERROR)\s+)?`(old|new):\/\/([^`]+)`\s*[:：]\s*(.+?)\s*$/iu;
+const REVIEW_HEADING = /^##\s+Review\s*$/iu;
+const FINDING_ENTRY = /^\s*-\s*(P0|P1|P2|QUESTION|INFO|WARNING|ERROR)\b\s*[:：]\s*(.*)$/iu;
+const REVIEW_REF_SCHEME = /^(old|new):\/\/(.+?)(?::L(\d+)(?:-L?(\d+))?)?$/iu;
+const REVIEW_REF_BARE_PATH = /^(?:[\w.@~-]+\/)+[\w.@~-]+\.[A-Za-z0-9]+$/u;
+function parseReviewRef(token) {
+  const trimmed = token.trim();
+  const scheme = REVIEW_REF_SCHEME.exec(trimmed);
+  if (scheme) {
+    const path = (scheme[2] ?? "").trim();
+    if (path.length === 0) {
+      return null;
+    }
+    const side = (scheme[1] ?? "new").toLowerCase();
+    const startRaw = scheme[3];
+    let range;
+    if (startRaw !== void 0) {
+      const start = Number(startRaw);
+      const end = scheme[4] === void 0 ? start : Number(scheme[4]);
+      if (Number.isInteger(start) && Number.isInteger(end) && start >= 1 && end >= start) {
+        range = { start, end };
+      }
+    }
+    return { path, side, ...range ? { range } : {}, raw: trimmed };
+  }
+  if (REVIEW_REF_BARE_PATH.test(trimmed)) {
+    return { path: trimmed, side: "new", raw: trimmed };
+  }
+  return null;
+}
+function extractReviewRefs(text) {
+  const refs = [];
+  for (const match of text.matchAll(CODE_SPAN)) {
+    const ref = parseReviewRef(match[1] ?? "");
+    if (ref) {
+      refs.push(ref);
+    }
+  }
+  return refs;
+}
+function parseReviewFindings(lines, baseLineNumber) {
+  const findings = [];
+  let current;
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    const bodyMarkdown = trimOuterBlankLines(current.bodyLines).join("\n").trim();
+    findings.push({
+      id: `finding-${findings.length + 1}`,
+      severity: current.severity,
+      bodyMarkdown,
+      refs: extractReviewRefs(bodyMarkdown),
+      line: current.line
+    });
+    current = void 0;
+  };
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    const entry = FINDING_ENTRY.exec(rawLine);
+    if (entry) {
+      flush();
+      current = {
+        severity: normalizeNoteSeverity(entry[1]),
+        bodyLines: [entry[2] ?? ""],
+        line: baseLineNumber + index
+      };
+      continue;
+    }
+    if (current) {
+      current.bodyLines.push(rawLine);
+    }
+  }
+  flush();
+  return findings;
+}
+function normalizeNoteSeverity(token) {
+  switch (token?.toUpperCase()) {
+    case "P0":
+    case "ERROR":
+      return "p0";
+    case "P1":
+    case "WARNING":
+      return "p1";
+    case "P2":
+      return "p2";
+    case "QUESTION":
+      return "question";
+    default:
+      return "info";
+  }
+}
+function parseReviewMarkdown(markdown, options = {}) {
+  const diagnostics = [];
+  const normalized = markdown.replace(/\r\n?/gu, "\n");
+  const lines = normalized.split("\n");
+  const { frontmatter, bodyStartIndex } = parseFrontmatter(lines, diagnostics);
+  const { groups, title, overview, findings } = parseGroups(lines, bodyStartIndex, diagnostics);
+  if (title === void 0) {
+    diagnostics.push({
+      severity: "warning",
+      message: 'Review should start the overview with a "# Title" heading.',
+      line: bodyStartIndex + 1,
+      code: "missing_review_title"
+    });
+  }
+  if (groups.length === 0) {
+    diagnostics.push({
+      severity: "error",
+      message: 'Review file must contain at least one "## Group: ..." section.',
+      code: "missing_group"
+    });
+  }
+  return {
+    ...options.sourcePath === void 0 ? {} : { sourcePath: options.sourcePath },
+    frontmatter,
+    ...title === void 0 ? {} : { title },
+    ...overview === void 0 ? {} : { overview },
+    findings,
+    groups,
+    diagnostics
+  };
+}
+function parseFrontmatter(lines, diagnostics) {
+  if (lines[0]?.trim() !== FRONTMATTER_DELIMITER) {
+    diagnostics.push({
+      severity: "error",
+      message: 'Review file must start with YAML frontmatter delimited by "---".',
+      line: 1,
+      code: "missing_frontmatter"
+    });
+    return {
+      frontmatter: fallbackFrontmatter({}),
+      bodyStartIndex: 0
+    };
+  }
+  const raw = {};
+  let endIndex = -1;
+  for (let index = 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line?.trim() === FRONTMATTER_DELIMITER) {
+      endIndex = index;
+      break;
+    }
+    const parsed = /^([A-Za-z0-9_-]+):\s*(.*?)\s*$/u.exec(line ?? "");
+    if (!parsed) {
+      diagnostics.push({
+        severity: "warning",
+        message: `Ignoring unsupported frontmatter line: ${line ?? ""}`,
+        line: index + 1,
+        code: "unsupported_frontmatter_line"
+      });
+      continue;
+    }
+    raw[parsed[1] ?? ""] = stripYamlScalar(parsed[2] ?? "");
+  }
+  if (endIndex === -1) {
+    diagnostics.push({
+      severity: "error",
+      message: 'Frontmatter is missing a closing "---" delimiter.',
+      line: 1,
+      code: "unterminated_frontmatter"
+    });
+    return { frontmatter: fallbackFrontmatter(raw), bodyStartIndex: lines.length };
+  }
+  const frontmatter = fallbackFrontmatter(raw);
+  if (raw.review_version !== "1") {
+    diagnostics.push({
+      severity: "error",
+      message: "frontmatter.review_version must be 1.",
+      line: 2,
+      code: "invalid_review_version"
+    });
+  }
+  if (!raw.merge_base) {
+    diagnostics.push({
+      severity: "error",
+      message: "frontmatter.merge_base is required.",
+      line: 2,
+      code: "missing_merge_base"
+    });
+  }
+  if (!raw.current_commit) {
+    diagnostics.push({
+      severity: "error",
+      message: "frontmatter.current_commit is required.",
+      line: 2,
+      code: "missing_current_commit"
+    });
+  }
+  if (raw.line_budget !== void 0 && !Number.isFinite(Number(raw.line_budget))) {
+    diagnostics.push({
+      severity: "warning",
+      message: `frontmatter.line_budget is not a number; using ${DEFAULT_LINE_BUDGET}.`,
+      line: 2,
+      code: "invalid_line_budget"
+    });
+  }
+  return { frontmatter, bodyStartIndex: endIndex + 1 };
+}
+function fallbackFrontmatter(raw) {
+  const parsedBudget = Number(raw.line_budget);
+  return {
+    reviewVersion: 1,
+    mergeBase: raw.merge_base ?? "",
+    currentCommit: raw.current_commit ?? "",
+    ...raw.base_ref === void 0 || raw.base_ref.length === 0 ? {} : { baseRef: raw.base_ref },
+    lineBudget: Number.isFinite(parsedBudget) && parsedBudget > 0 ? parsedBudget : DEFAULT_LINE_BUDGET,
+    pr: parsePullRequest(raw),
+    raw
+  };
+}
+function parsePullRequest(raw) {
+  const numberRaw = raw.pr_number;
+  const urlRaw = raw.pr_url;
+  if (numberRaw === void 0 && urlRaw === void 0) {
+    return void 0;
+  }
+  const number = Number(numberRaw);
+  const url = urlRaw ?? "";
+  if (!Number.isInteger(number) || number <= 0) {
+    return void 0;
+  }
+  if (!isValidUrl(url)) {
+    return void 0;
+  }
+  const title = raw.pr_title;
+  return {
+    number,
+    url,
+    ...title === void 0 || title.length === 0 ? {} : { title }
+  };
+}
+function stripYamlScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseGroups(lines, bodyStartIndex, diagnostics) {
+  const groups = [];
+  const overviewLines = [];
+  const reviewLines = [];
+  let reviewStartLine = 0;
+  let inReview = false;
+  let currentGroup;
+  let currentBlock;
+  for (let index = bodyStartIndex; index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    const lineNumber = index + 1;
+    const heading = GROUP_HEADING.exec(rawLine);
+    if (heading) {
+      inReview = false;
+      currentGroup = {
+        id: `group-${groups.length + 1}`,
+        title: heading[1]?.trim() ?? `Group ${groups.length + 1}`,
+        commits: [],
+        bodyLines: [],
+        blocks: [],
+        line: lineNumber
+      };
+      groups.push(currentGroup);
+      currentBlock = void 0;
+      continue;
+    }
+    if (!currentGroup && REVIEW_HEADING.test(rawLine)) {
+      inReview = true;
+      reviewStartLine = lineNumber + 1;
+      continue;
+    }
+    if (!currentGroup) {
+      (inReview ? reviewLines : overviewLines).push(rawLine);
+      continue;
+    }
+    const changedLines = CHANGED_LINES.exec(rawLine);
+    if (changedLines) {
+      currentGroup.changedLines = Number(changedLines[1]);
+      currentGroup.bodyLines.push(rawLine);
+      continue;
+    }
+    const commits = COMMITS.exec(rawLine);
+    if (commits) {
+      currentGroup.commits = parseCommits(commits[1] ?? "");
+      currentGroup.bodyLines.push(rawLine);
+      continue;
+    }
+    const changeRef = CHANGE_REF.exec(rawLine.trim());
+    if (changeRef) {
+      const parsedRef = parseChangeReference(changeRef[1] ?? "");
+      if (!parsedRef) {
+        diagnostics.push({
+          severity: "error",
+          message: `Invalid changes reference: ${changeRef[1] ?? ""}`,
+          line: lineNumber,
+          code: "invalid_changes_reference"
+        });
+        currentBlock = void 0;
+        continue;
+      }
+      currentBlock = {
+        id: `${currentGroup.id}-block-${currentGroup.blocks.length + 1}`,
+        path: parsedRef.path,
+        kind: "change",
+        ...parsedRef.oldRange === void 0 ? {} : { oldRange: parsedRef.oldRange },
+        ...parsedRef.newRange === void 0 ? {} : { newRange: parsedRef.newRange },
+        notes: [],
+        line: lineNumber,
+        rawReference: changeRef[1] ?? ""
+      };
+      currentGroup.blocks.push(currentBlock);
+      continue;
+    }
+    const contextRef = CONTEXT_REF.exec(rawLine.trim());
+    if (contextRef) {
+      const parsedRef = parseContextReference(contextRef[1] ?? "");
+      if (!parsedRef) {
+        diagnostics.push({
+          severity: "error",
+          message: `Invalid context reference: ${contextRef[1] ?? ""}`,
+          line: lineNumber,
+          code: "invalid_context_reference"
+        });
+        currentBlock = void 0;
+        continue;
+      }
+      currentBlock = {
+        id: `${currentGroup.id}-block-${currentGroup.blocks.length + 1}`,
+        path: parsedRef.path,
+        kind: "context",
+        newRange: parsedRef.range,
+        notes: [],
+        line: lineNumber,
+        rawReference: contextRef[1] ?? ""
+      };
+      currentGroup.blocks.push(currentBlock);
+      continue;
+    }
+    const noteRef = NOTE_REF.exec(rawLine);
+    if (noteRef) {
+      const side = noteRef[2]?.toLowerCase();
+      if (!currentBlock) {
+        diagnostics.push({
+          severity: "error",
+          message: `${side ?? "line"} reference has no preceding changes:// block.`,
+          line: lineNumber,
+          code: "unbound_line_reference"
+        });
+        continue;
+      }
+      const range = parseLineRange(noteRef[3] ?? "");
+      if (!range) {
+        diagnostics.push({
+          severity: "error",
+          message: `Invalid ${side} line range: ${noteRef[3] ?? ""}`,
+          line: lineNumber,
+          code: "invalid_line_range"
+        });
+        continue;
+      }
+      currentBlock.notes.push({
+        id: `${currentBlock.id}-note-${currentBlock.notes.length + 1}`,
+        side,
+        severity: normalizeNoteSeverity(noteRef[1]),
+        range,
+        body: noteRef[4] ?? "",
+        path: currentBlock.path,
+        blockId: currentBlock.id,
+        line: lineNumber
+      });
+      continue;
+    }
+    currentGroup.bodyLines.push(rawLine);
+  }
+  const trimmedOverview = trimOuterBlankLines(overviewLines);
+  let title;
+  if (trimmedOverview.length > 0) {
+    const firstLine = trimmedOverview[0]?.trim() ?? "";
+    const titleMatch = /^#\s+(.+)$/u.exec(firstLine);
+    if (titleMatch) {
+      title = titleMatch[1]?.trim();
+      trimmedOverview.shift();
+    }
+  }
+  const overview = trimOuterBlankLines(trimmedOverview).join("\n").trim();
+  const resolvedGroups = groups.map((group) => ({
+    id: group.id,
+    title: group.title,
+    ...group.changedLines === void 0 ? {} : { changedLines: group.changedLines },
+    commits: group.commits,
+    bodyMarkdown: trimOuterBlankLines(group.bodyLines).join("\n"),
+    blocks: group.blocks.map((block) => ({
+      id: block.id,
+      path: block.path,
+      kind: block.kind,
+      ...block.oldRange === void 0 ? {} : { oldRange: block.oldRange },
+      ...block.newRange === void 0 ? {} : { newRange: block.newRange },
+      notes: block.notes,
+      line: block.line,
+      rawReference: block.rawReference
+    })),
+    line: group.line
+  }));
+  const findings = parseReviewFindings(reviewLines, reviewStartLine);
+  return {
+    groups: resolvedGroups,
+    findings,
+    ...title === void 0 ? {} : { title },
+    ...overview.length === 0 ? {} : { overview }
+  };
+}
+function parseCommits(value) {
+  const commits = [];
+  for (const match of value.matchAll(CODE_SPAN)) {
+    const commit = match[1]?.trim();
+    if (commit) {
+      commits.push(commit);
+    }
+  }
+  if (commits.length > 0) {
+    return commits;
+  }
+  return value.split(",").map((part) => part.trim()).filter(Boolean);
+}
+function parseChangeReference(reference) {
+  if (!reference.startsWith("changes://")) {
+    return void 0;
+  }
+  const withoutScheme = reference.slice("changes://".length);
+  const queryStart = withoutScheme.indexOf("?");
+  const rawPath = queryStart === -1 ? withoutScheme : withoutScheme.slice(0, queryStart);
+  const query = queryStart === -1 ? "" : withoutScheme.slice(queryStart + 1);
+  const path = safeDecode(rawPath);
+  if (path.length === 0 || path.startsWith("/")) {
+    return void 0;
+  }
+  const params = new URLSearchParams(query);
+  const oldRange = parseLineRange(params.get("old") ?? "");
+  const newRange = parseLineRange(params.get("new") ?? "");
+  return {
+    path,
+    ...oldRange === void 0 ? {} : { oldRange },
+    ...newRange === void 0 ? {} : { newRange }
+  };
+}
+function parseContextReference(reference) {
+  if (!reference.startsWith("context://")) {
+    return void 0;
+  }
+  const withoutScheme = reference.slice("context://".length);
+  const queryStart = withoutScheme.indexOf("?");
+  const rawPath = queryStart === -1 ? withoutScheme : withoutScheme.slice(0, queryStart);
+  const query = queryStart === -1 ? "" : withoutScheme.slice(queryStart + 1);
+  const path = safeDecode(rawPath);
+  if (path.length === 0 || path.startsWith("/")) {
+    return void 0;
+  }
+  const params = new URLSearchParams(query);
+  const range = parseLineRange(params.get("range") ?? params.get("L") ?? "");
+  if (range === void 0) {
+    return void 0;
+  }
+  return { path, range };
+}
+function parseLineRange(value) {
+  const trimmed = value.trim();
+  const match = /^L(\d+)(?:-L?(\d+))?$/iu.exec(trimmed);
+  if (!match) {
+    return void 0;
+  }
+  const start = Number(match[1]);
+  const end = Number(match[2] ?? match[1]);
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start <= 0 || end < start) {
+    return void 0;
+  }
+  return { start, end };
+}
+function trimOuterBlankLines(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && lines[start]?.trim() === "") {
+    start += 1;
+  }
+  while (end > start && lines[end - 1]?.trim() === "") {
+    end -= 1;
+  }
+  return lines.slice(start, end);
+}
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function isValidUrl(value) {
+  try {
+    void new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateParsedReviewDocument(document) {
+  const diagnostics = [...document.diagnostics];
+  const budget = document.frontmatter.lineBudget;
+  for (const group of document.groups) {
+    if (group.changedLines !== void 0 && group.changedLines > budget) {
+      diagnostics.push({
+        severity: "warning",
+        message: `Group "${group.title}" declares ${group.changedLines} changed lines, above budget ${budget}.`,
+        line: group.line,
+        code: "group_over_budget"
+      });
+    }
+    const changeBlocks = group.blocks.filter((block) => block.kind === "change");
+    if (group.blocks.length === 0) {
+      diagnostics.push({
+        severity: "warning",
+        message: `Group "${group.title}" has no changes:// or context:// block.`,
+        line: group.line,
+        code: "group_without_blocks"
+      });
+    } else if (changeBlocks.length === 0) {
+      diagnostics.push({
+        severity: "info",
+        message: `Group "${group.title}" contains only context:// blocks.`,
+        line: group.line,
+        code: "group_only_context_blocks"
+      });
+    }
+  }
+  const renderedPaths = /* @__PURE__ */ new Set();
+  for (const group of document.groups) {
+    for (const block of group.blocks) {
+      renderedPaths.add(block.path);
+    }
+  }
+  for (const finding of document.findings ?? []) {
+    for (const ref of finding.refs) {
+      if (!renderedPaths.has(ref.path)) {
+        diagnostics.push({
+          severity: "warning",
+          message: `Review finding references "${ref.path}", which is not shown in any group (its chip will not jump anywhere).`,
+          line: finding.line,
+          code: "finding_ref_unresolved"
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+function collectBundleDiagnostics(bundle) {
+  return [
+    ...bundle.diagnostics,
+    ...bundle.groups.flatMap((group) => group.diagnostics),
+    ...bundle.groups.flatMap((group) => group.blocks.flatMap((block) => block.diagnostics)),
+    ...Object.values(bundle.files).flatMap((file) => file.diagnostics)
+  ];
+}
+function validateResolvedBlock(block) {
+  const diagnostics = [];
+  const file = block.file;
+  if (!file) {
+    diagnostics.push({
+      severity: "error",
+      message: `No Git diff data was resolved for ${block.path}.`,
+      line: block.line,
+      code: "missing_resolved_file"
+    });
+    return diagnostics;
+  }
+  validateRange(block.oldRange, file.oldText, "old", block.line, diagnostics);
+  validateRange(block.newRange, file.newText, "new", block.line, diagnostics);
+  for (const note of block.notes) {
+    validateRange(
+      note.range,
+      note.side === "old" ? file.oldText : file.newText,
+      note.side,
+      note.line,
+      diagnostics
+    );
+  }
+  return diagnostics;
+}
+function validateRange(range, text, side, line, diagnostics) {
+  if (!range) {
+    return;
+  }
+  const lineCount = countLines(text);
+  if (range.end > lineCount) {
+    diagnostics.push({
+      severity: "error",
+      message: `${side}://L${range.start}-L${range.end} exceeds ${side} file line count ${lineCount}.`,
+      line,
+      code: "line_reference_out_of_bounds"
+    });
+  }
+}
+function countLines(text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  return text.endsWith("\n") ? text.slice(0, -1).split("\n").length : text.split("\n").length;
+}
+function hasErrorDiagnostics(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+const RANGE_CONTEXT_LINES = 3;
+function createSparseTextForRanges(text, ranges, contextLines = RANGE_CONTEXT_LINES) {
+  if (ranges.length === 0) {
+    return text;
+  }
+  const lines = splitSourceLines(text);
+  const keep = /* @__PURE__ */ new Set();
+  for (const range of ranges) {
+    const start = Math.max(1, range.start - contextLines);
+    const end = Math.min(lines.length, range.end + contextLines);
+    for (let line = start; line <= end; line += 1) {
+      keep.add(line);
+    }
+  }
+  return lines.map((line, index) => keep.has(index + 1) ? line : "").join("\n");
+}
+function splitSourceLines(text) {
+  if (text.length === 0) {
+    return [];
+  }
+  return text.endsWith("\n") ? text.slice(0, -1).split("\n") : text.split("\n");
+}
+export {
+  countLines as a,
+  createSparseTextForRanges as b,
+  collectBundleDiagnostics as c,
+  parseReviewMarkdown as d,
+  parseReviewRef as e,
+  validateResolvedBlock as f,
+  hasErrorDiagnostics as h,
+  parseLineRange as p,
+  validateParsedReviewDocument as v
+};