semantic-code-review 0.24.2__py3-none-any.whl

semantic_code_review/viewer/assets/folds.ts

@@ -0,0 +1,560 @@
+// Indent-based fold detection + on-demand fold-summary requests.
+//
+// The viewer's fold story is unified per-file (not per-stretch):
+// `attachFileFolds(fileEl, file)` walks every visible row in the
+// file body in DOM order — across hunks and adjacent expanded
+// context blocks — runs an indent-based fold detector over the
+// unified sequence, and attaches one chevron per region. Folds
+// whose body spans a hunk boundary collapse the right rows in
+// every container because each row carries its own DOM refs.
+//
+// First time the reviewer collapses a region whose summary is
+// empty, this module fires `POST /fold-summary` against the live
+// review server. The response writes back into the region object
+// (mutating DATA in place); the server's `fold-summary` SSE event
+// is handled by `applyFoldSummary` in boot.ts.
+//
+import { Annotations, type AnnotationHandle } from "./annotations";
+import { FileRows, type RowWithEls } from "./file_rows";
+
+interface DetectedRegion {
+  header_idx: number;
+  body_start_idx: number;
+  body_end_idx: number;
+  context: FoldContext;
+  right_start: number | null;
+  right_end: number | null;
+  left_start: number | null;
+  left_end: number | null;
+  // Identity of the definition the region snapped to; null for an
+  // indentation-fallback region.
+  qualified_name: string | null;
+  kind: string | null;
+}
+
+interface AttachedFold {
+  marker: SVGElement;
+  foldHandle: AnnotationHandle | null;
+}
+
+interface FoldRequestAddress {
+  context: FoldContext;
+  right_start?: number;
+  right_end?: number;
+  left_start?: number;
+  left_end?: number;
+}
+
+interface FoldFileState {
+  handles: AnnotationHandle[];
+  chevrons: SVGElement[];
+}
+
+const _FILE_FOLD_STATE: Record<string, FoldFileState> = Object.create(null);
+
+function _sessionEndpoint(): string | null {
+  // Read at call time, not module init — the meta tag may be
+  // injected after this module loads (tests set up the DOM
+  // dynamically, and a future bootloader might too). Empty
+  // string content means "same origin" (the production case);
+  // a missing meta tag (null) means no server is available
+  // and the route is wired off.
+  if (typeof document === "undefined") return null;
+  const m = document.querySelector('meta[name="scr-session-endpoint"]');
+  if (!m) return null;
+  return m.getAttribute("content") || "";
+}
+
+// --- DOM helpers (private, duplicated from viewer.js because the
+// classic-script module boundary doesn't let us import them) ----------
+
+const _SVG_NS = "http://www.w3.org/2000/svg";
+
+function _chev(folded: boolean, extraClass: string): SVGElement {
+  const svg = document.createElementNS(_SVG_NS, "svg") as unknown as SVGElement;
+  svg.setAttribute("viewBox", "0 0 12 12");
+  svg.setAttribute("aria-hidden", "true");
+  svg.classList.add("chevron");
+  svg.classList.add(extraClass);
+  if (!folded) svg.classList.add("open");
+  const path = document.createElementNS(_SVG_NS, "path");
+  path.setAttribute("d", "M4.25 2.75 L8 6 L4.25 9.25");
+  path.setAttribute("fill", "none");
+  path.setAttribute("stroke", "currentColor");
+  path.setAttribute("stroke-width", "1.75");
+  path.setAttribute("stroke-linecap", "round");
+  path.setAttribute("stroke-linejoin", "round");
+  svg.appendChild(path);
+  return svg;
+}
+
+function _isRowContentEmpty(rowEl: HTMLElement | undefined | null): boolean {
+  if (!rowEl) return true;
+  const content = rowEl.children[1];
+  return !content || content.classList.contains("empty");
+}
+
+// --- File-level walker --------------------------------------------------
+
+function _teardownFileFolds(fileId: string): void {
+  const s = _FILE_FOLD_STATE[fileId];
+  if (!s) return;
+  for (const h of s.handles) {
+    try { h.remove(); } catch (_) { /* ignore */ }
+  }
+  for (const c of s.chevrons) {
+    try { c.remove(); } catch (_) { /* ignore */ }
+  }
+  delete _FILE_FOLD_STATE[fileId];
+}
+
+// Walk the file body's .diff / .gap-expansion containers in DOM order,
+// pull each one's row stream out of `FileRows` (recorded by render.ts
+// at construction time), and flatten into one indexable list so folds
+// can straddle hunks and adjacent gap-context.
+function _collectFileRows(fileEl: HTMLElement): RowWithEls[] {
+  const body = fileEl.querySelector(".file-body");
+  if (!body) return [];
+  const out: RowWithEls[] = [];
+  for (const child of Array.from(body.children) as HTMLElement[]) {
+    const cls = child.classList;
+    let source: HTMLElement | null = null;
+    if (cls.contains("hunk")) {
+      source = child.querySelector(".diff");
+    } else if (cls.contains("gap-expansion")) {
+      source = child;
+    }
+    if (!source) continue;
+    const entry = FileRows.get(source);
+    if (!entry) continue;
+    for (let i = 0; i < entry.rows.length; i++) {
+      out.push({
+        ...entry.rows[i],
+        oldEl: entry.oldEls[i], newEl: entry.newEls[i],
+      });
+    }
+  }
+  return out;
+}
+
+function _findExistingFoldRecord(
+  file: FileBlock, det: DetectedRegion,
+): FoldRegion | null {
+  const rs = det.right_start || 0, re_ = det.right_end || 0;
+  const ls = det.left_start || 0, le = det.left_end || 0;
+  for (const h of file.hunks || []) {
+    for (const r of h.fold_regions || []) {
+      if (
+        (r.context || "right") === det.context
+        && (r.right_start || 0) === rs && (r.right_end || 0) === re_
+        && (r.left_start || 0) === ls && (r.left_end || 0) === le
+      ) {
+        return r;
+      }
+    }
+  }
+  return null;
+}
+
+function _upsertFoldRegion(
+  file: FileBlock, det: DetectedRegion, rows: RowWithEls[],
+): FoldRegion {
+  // The local POST handler and the SSE updater both mutate the
+  // region object's `summary` field — they need to point at the
+  // same reference. Find a matching persistent record if one
+  // exists, refresh its detected fields, and return it. Otherwise
+  // create a new one and stash it on the file's first hunk so the
+  // next render picks it up.
+  const hasChanges = _anyChangesInRange(rows, det.header_idx, det.body_end_idx);
+  const existing = _findExistingFoldRecord(file, det);
+  if (existing) {
+    existing.header_idx = det.header_idx;
+    existing.body_start_idx = det.body_start_idx;
+    existing.body_end_idx = det.body_end_idx;
+    existing.has_changes = hasChanges;
+    existing.qualified_name = det.qualified_name;
+    existing.kind = det.kind;
+    return existing;
+  }
+  const candidate: FoldRegion = {
+    header_idx: det.header_idx,
+    body_start_idx: det.body_start_idx,
+    body_end_idx: det.body_end_idx,
+    context: det.context,
+    right_start: det.right_start, right_end: det.right_end,
+    left_start: det.left_start, left_end: det.left_end,
+    has_changes: hasChanges,
+    qualified_name: det.qualified_name, kind: det.kind,
+    summary: "",
+  };
+  if (file.hunks && file.hunks.length > 0) {
+    const h0 = file.hunks[0];
+    if (!h0.fold_regions) h0.fold_regions = [];
+    h0.fold_regions.push(candidate);
+  }
+  return candidate;
+}
+
+function _anyChangesInRange(
+  rows: RowWithEls[], start: number, end: number,
+): boolean {
+  for (let i = start; i <= end; i++) {
+    const k = rows[i].kind;
+    if (k === "ins" || k === "del" || k === "pair") return true;
+  }
+  return false;
+}
+
+// --- Indent-based detection --------------------------------------------
+
+function _rowIndent(row: RowBlock): number {
+  const text = row.kind === "del" ? row.old_text : row.new_text;
+  if (!text || !text.trim()) return -1;
+  let ind = 0;
+  for (const ch of text) {
+    if (ch === " ") ind += 1;
+    else if (ch === "\t") ind += 4;
+    else break;
+  }
+  return ind;
+}
+
+function _indentRawRegions(rows: RowWithEls[]): Array<[number, number]> {
+  const indents = rows.map(_rowIndent);
+  const nextNonBlank = (i: number): number | null => {
+    for (let j = i + 1; j < indents.length; j++) {
+      if (indents[j] !== -1) return indents[j];
+    }
+    return null;
+  };
+  const raw: Array<[number, number]> = [];
+  const stack: Array<[number, number]> = [];
+  for (let i = 0; i < indents.length; i++) {
+    const ind = indents[i];
+    if (ind === -1) continue;
+    while (stack.length && stack[stack.length - 1][0] >= ind) {
+      const top = stack.pop()!;
+      raw.push([top[1], i - 1]);
+    }
+    const ni = nextNonBlank(i);
+    if (ni !== null && ni > ind) stack.push([ind, i]);
+  }
+  while (stack.length) {
+    const top = stack.pop()!;
+    raw.push([top[1], indents.length - 1]);
+  }
+  return raw;
+}
+
+// Definition spans enclosing a row, outermost-first: the row maps by
+// line number into one side's tree — new_line into head spans (ctx /
+// pair / ins rows), else old_line into base spans (del-only rows).
+function _rowSymbols(
+  row: RowWithEls, headSpans: FoldSymbolSpan[], baseSpans: FoldSymbolSpan[],
+): FoldSymbolSpan[] {
+  let line: number | null;
+  let spans: FoldSymbolSpan[];
+  if (row.new_line != null) { line = row.new_line; spans = headSpans; }
+  else if (row.old_line != null) { line = row.old_line; spans = baseSpans; }
+  else return [];
+  return spans
+    .filter((s) => s.start_line <= line! && line! <= s.end_line)
+    .sort((a, b) => a.depth - b.depth);
+}
+
+// `(headerIdx, bodyEndIdx, qualifiedName, kind)` snapped to definition
+// spans, plus the set of row indices inside any definition. Every
+// definition with >=1 present row becomes a region from its first to its
+// last present row carrying that definition's identity; nested defs nest
+// because a row carries its whole enclosing chain.
+type RawRegion = [number, number, string | null, string | null];
+
+function _symbolRawRegions(
+  rows: RowWithEls[], headSpans: FoldSymbolSpan[], baseSpans: FoldSymbolSpan[],
+): { raw: RawRegion[]; covered: Set<number> } {
+  const runs = new Map<string, [number, number]>();
+  const kinds = new Map<string, string>();
+  const order: string[] = [];
+  const covered = new Set<number>();
+  for (let i = 0; i < rows.length; i++) {
+    for (const s of _rowSymbols(rows[i], headSpans, baseSpans)) {
+      covered.add(i);
+      const run = runs.get(s.qualified_name);
+      if (run === undefined) {
+        runs.set(s.qualified_name, [i, i]);
+        kinds.set(s.qualified_name, s.kind);
+        order.push(s.qualified_name);
+      } else {
+        run[1] = i;
+      }
+    }
+  }
+  const raw: RawRegion[] = order.map((qn) => {
+    const run = runs.get(qn)!;
+    return [run[0], run[1], qn, kinds.get(qn)!];
+  });
+  return { raw, covered };
+}
+
+function _computeFoldRegions(
+  rows: RowWithEls[],
+  headSpans: FoldSymbolSpan[] = [],
+  baseSpans: FoldSymbolSpan[] = [],
+): DetectedRegion[] {
+  // Uniform shape: [headerIdx, bodyEndIdx, qualifiedName|null, kind|null].
+  // Indentation regions carry no symbol.
+  let raw: RawRegion[];
+  if (headSpans.length || baseSpans.length) {
+    const sym = _symbolRawRegions(rows, headSpans, baseSpans);
+    // Keep an indentation region only where no row it spans is already
+    // covered by a definition — the snapped region owns that stretch.
+    raw = sym.raw.concat(
+      _indentRawRegions(rows)
+        .filter(([h, e]) => {
+          for (let j = h; j <= e; j++) if (sym.covered.has(j)) return false;
+          return true;
+        })
+        .map(([h, e]): RawRegion => [h, e, null, null]),
+    );
+  } else {
+    raw = _indentRawRegions(rows).map(([h, e]): RawRegion => [h, e, null, null]);
+  }
+  raw.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const regions: DetectedRegion[] = [];
+  for (const [header_idx, body_end, qualified_name, kind] of raw) {
+    const body_start = header_idx + 1;
+    if (body_start > body_end) continue;
+    const right_start = _firstLine(rows, header_idx, body_end, "new_line");
+    const right_end = _lastLine(rows, header_idx, body_end, "new_line");
+    const left_start = _firstLine(rows, header_idx, body_end, "old_line");
+    const left_end = _lastLine(rows, header_idx, body_end, "old_line");
+    const hasChanges = _anyChangesInRange(rows, header_idx, body_end);
+    let context: FoldContext;
+    if (right_start != null && left_start != null && hasChanges) context = "both";
+    else if (right_start != null) context = "right";
+    else context = "left";
+    regions.push({
+      header_idx, body_start_idx: body_start, body_end_idx: body_end,
+      context, right_start, right_end, left_start, left_end,
+      qualified_name, kind,
+    });
+  }
+  return regions;
+}
+
+function _firstLine(
+  rows: RowWithEls[], start: number, end: number, attr: "new_line" | "old_line",
+): number | null {
+  for (let j = start; j <= end; j++) {
+    const v = rows[j][attr];
+    if (v != null) return v;
+  }
+  return null;
+}
+
+function _lastLine(
+  rows: RowWithEls[], start: number, end: number, attr: "new_line" | "old_line",
+): number | null {
+  for (let j = end; j >= start; j--) {
+    const v = rows[j][attr];
+    if (v != null) return v;
+  }
+  return null;
+}
+
+// --- Attach + click ----------------------------------------------------
+
+function _canRequestFoldSummary(
+  fileIdx: number | null, region: FoldRegion,
+): boolean {
+  if (_sessionEndpoint() === null) return false;
+  if (fileIdx == null) return false;
+  return _foldAddress(region) !== null;
+}
+
+function _foldAddress(region: FoldRegion): FoldRequestAddress | null {
+  const context = region.context || "right";
+  const addr: FoldRequestAddress = { context };
+  if (context === "right" || context === "both") {
+    if (region.right_start == null || region.right_end == null) return null;
+    addr.right_start = region.right_start;
+    addr.right_end = region.right_end;
+  }
+  if (context === "left" || context === "both") {
+    if (region.left_start == null || region.left_end == null) return null;
+    addr.left_start = region.left_start;
+    addr.left_end = region.left_end;
+  }
+  return addr;
+}
+
+// Prefix the collapsed placeholder with the region's symbol identity,
+// e.g. "function Foo.bar — ". Empty for an indentation-fallback region
+// (no symbol), which keeps today's unlabelled placeholder.
+function _foldLabel(region: FoldRegion): string {
+  if (!region.qualified_name) return "";
+  const kind = region.kind ? `${region.kind} ` : "";
+  return `${kind}${region.qualified_name} — `;
+}
+
+function _requestFoldSummary(
+  fileIdx: number, region: FoldRegion,
+  foldHandle: AnnotationHandle,
+): void {
+  if (region._inflight || region.summary) return;
+  const addr = _foldAddress(region);
+  if (!addr) return;
+  region._inflight = true;
+  const label = _foldLabel(region);
+  _setFoldBoxContent(foldHandle, label + "summarising…", { pending: true });
+  const retry = (): void => _requestFoldSummary(fileIdx, region, foldHandle);
+  fetch(_sessionEndpoint() + "/fold-summary", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ file_idx: fileIdx, ...addr }),
+  })
+    .then((r) => r.json().then((j: { summary?: string }) => ({ status: r.status, body: j })))
+    .then(({ status, body }) => {
+      region._inflight = false;
+      if (status === 200 && body.summary) {
+        region.summary = body.summary;
+        _setFoldBoxContent(foldHandle, label + body.summary, {});
+      } else {
+        _setFoldBoxContent(
+          foldHandle, label + "(summary failed — click to retry)",
+          { failed: true }, retry,
+        );
+      }
+    })
+    .catch(() => {
+      region._inflight = false;
+      _setFoldBoxContent(
+        foldHandle, label + "(summary failed — click to retry)",
+        { failed: true }, retry,
+      );
+    });
+}
+
+function _setFoldBoxContent(
+  foldHandle: AnnotationHandle, text: string,
+  classes: { pending?: boolean; failed?: boolean },
+  onClick?: () => void,
+): void {
+  if (!foldHandle || !foldHandle.element) return;
+  const box = foldHandle.element.querySelector(".annot-box") as HTMLElement | null;
+  if (!box) return;
+  box.textContent = text;
+  box.classList.remove("pending", "failed");
+  if (classes.pending) box.classList.add("pending");
+  if (classes.failed) box.classList.add("failed");
+  if (onClick) {
+    const clone = box.cloneNode(true) as HTMLElement;
+    clone.style.cursor = "pointer";
+    clone.addEventListener("click", onClick);
+    box.replaceWith(clone);
+  }
+  foldHandle.resize();
+}
+
+function _attachOneFold(
+  rows: RowWithEls[], region: FoldRegion, fileIdx: number,
+): AttachedFold | null {
+  const bodyStart = region.body_start_idx;
+  const bodyEnd = region.body_end_idx;
+  if (bodyStart > bodyEnd) return null;
+
+  const headerRow = rows[region.header_idx];
+  if (!headerRow) return null;
+  const headerOld = headerRow.oldEl;
+  const headerNew = headerRow.newEl;
+  if (!headerOld && !headerNew) return null;
+
+  const side = _isRowContentEmpty(headerNew) && !_isRowContentEmpty(headerOld)
+    ? "old" : "new";
+  const anchor = side === "new" ? headerNew : headerOld;
+  const shadow = side === "new" ? headerOld : headerNew;
+
+  const marker = _chev(false, "fold-chev");
+  marker.setAttribute("role", "button");
+  marker.setAttribute("tabindex", "0");
+
+  let foldHandle: AnnotationHandle | null = null;
+  const canSummarise = _canRequestFoldSummary(fileIdx, region);
+  if (region.summary || region.has_changes || canSummarise) {
+    // Seed the placeholder with the symbol identity (if any) followed by
+    // the summary or its pending/run-augment stand-in.
+    const label = _foldLabel(region);
+    const pending = !region.summary && canSummarise;
+    const bodyText = region.summary
+      || (canSummarise
+        ? "summarising…"
+        : "(changes here; run augment to generate a description)");
+    foldHandle = Annotations.attach({
+      anchor, shadowAnchor: shadow,
+      variant: "fold", content: label + bodyText,
+    });
+    if (!region.summary) {
+      const box = foldHandle.element.querySelector(".annot-box");
+      if (box) box.classList.add("missing");
+      if (pending && box) box.classList.add("pending");
+    }
+    foldHandle.element.style.display = "none";
+    if (foldHandle.placeholder) foldHandle.placeholder.style.display = "none";
+  }
+
+  marker.addEventListener("click", (e) => {
+    e.stopPropagation();
+    const nowOpen = marker.classList.toggle("open");
+    for (let i = bodyStart; i <= bodyEnd; i++) {
+      const r = rows[i];
+      if (!r) continue;
+      if (r.oldEl) r.oldEl.style.display = nowOpen ? "" : "none";
+      if (r.newEl) r.newEl.style.display = nowOpen ? "" : "none";
+    }
+    if (foldHandle) {
+      foldHandle.element.style.display = nowOpen ? "none" : "";
+      if (foldHandle.placeholder) {
+        foldHandle.placeholder.style.display = nowOpen ? "none" : "";
+      }
+      if (!nowOpen) foldHandle.resize();
+    }
+    if (!nowOpen && !region.summary && foldHandle
+        && _canRequestFoldSummary(fileIdx, region)) {
+      _requestFoldSummary(fileIdx, region, foldHandle);
+    }
+    Annotations.reflow(anchor);
+  });
+
+  const contentCell = anchor && (anchor.children[1] as HTMLElement | undefined);
+  if (contentCell) contentCell.prepend(marker);
+  return { marker, foldHandle };
+}
+
+function attachFileFolds(fileEl: HTMLElement, file: FileBlock): void {
+  _teardownFileFolds(file.id);
+  const fileIdx = Number(file.id.replace("F", ""));
+  const rows = _collectFileRows(fileEl);
+  if (rows.length === 0) return;
+  const syms = file.fold_symbols || { head: [], base: [] };
+  const detected = _computeFoldRegions(rows, syms.head, syms.base);
+  const handles: AnnotationHandle[] = [];
+  const chevrons: SVGElement[] = [];
+  for (const det of detected) {
+    const region = _upsertFoldRegion(file, det, rows);
+    const attached = _attachOneFold(rows, region, fileIdx);
+    if (!attached) continue;
+    if (attached.foldHandle) handles.push(attached.foldHandle);
+    if (attached.marker) chevrons.push(attached.marker);
+  }
+  _FILE_FOLD_STATE[file.id] = { handles, chevrons };
+}
+
+// The single runtime surface. boot.ts calls attachFileFolds on
+// initial render, after every gap expand/collapse, and from
+// applyFoldSummary's cross-tab path.
+export const Folds = { attachFileFolds };
+
+// Exposed for the cross-language lockstep fixture (tests/js/folds.test.ts):
+// the same (rows, spans) input must yield the same regions as the Python
+// `compute_fold_regions`. Not used by the runtime bundle.
+export { _computeFoldRegions };

semantic_code_review/viewer/assets/index.html

@@ -0,0 +1,62 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="scr-session-endpoint" content="">
+  <title>Semantic Code Review</title>
+  <link rel="stylesheet" media="(prefers-color-scheme: dark)" href="/static/vendor/github-dark.min.css">
+  <link rel="stylesheet" media="(prefers-color-scheme: light)" href="/static/vendor/github.min.css">
+  <link rel="stylesheet" href="/static/viewer.css">
+</head>
+<body>
+  <header class="pr-bar">
+    <div class="pr-title">
+      <span class="pr-meta"></span>
+    </div>
+    <div class="fold-slider" role="tablist" aria-label="Fold level">
+      <button data-fold="files" title="Collapse to files (1)">Files</button>
+      <button data-fold="hunks" title="Collapse to hunks (2)">Hunks</button>
+      <button data-fold="segments" title="Collapse to segments (3)">Segments</button>
+      <button data-fold="off" title="Fully expanded (4)">Off</button>
+    </div>
+    <button id="reset-btn" class="reset-btn" title="Clear per-region overrides">Reset</button>
+    <button id="help-btn" class="help-btn" title="Help (?)" aria-label="Help">?</button>
+  </header>
+
+  <div id="scr-progress" class="scr-progress hidden" aria-live="polite">
+    <div class="scr-progress-summary">
+      <span class="scr-progress-overview" data-state="pending">Overview</span>
+      <span class="scr-progress-hunks">Hunks <span class="scr-progress-done">0</span>/<span class="scr-progress-total">0</span></span>
+      <span class="scr-progress-detail">
+        (<span class="scr-progress-running">0</span> running &middot;
+        <span class="scr-progress-queued">0</span> queued &middot;
+        <span class="scr-progress-failed">0</span> failed)
+      </span>
+    </div>
+    <div class="scr-progress-grid" role="list" aria-label="Hunk progress"></div>
+  </div>
+
+  <div class="layout">
+    <aside id="group-sidebar" class="group-sidebar"></aside>
+    <main id="app"></main>
+  </div>
+
+  <footer id="status-bar" class="status-bar">
+    <span id="status-counts" class="status-counts"></span>
+  </footer>
+
+  <div id="help-overlay" class="help-overlay hidden" role="dialog" aria-label="Help">
+    <div class="help-card">
+      <h3>Keyboard shortcuts</h3>
+      <p><kbd>1</kbd> fold to files &middot; <kbd>2</kbd> hunks &middot; <kbd>3</kbd> segments &middot; <kbd>4</kbd> expand</p>
+      <p><kbd>?</kbd> toggle this help &middot; <kbd>Esc</kbd> close</p>
+      <p>Click any region header to toggle its fold state independently.
+         "Reset" clears per-region overrides and applies the global fold level.</p>
+    </div>
+  </div>
+
+  <script src="/static/vendor/highlight.min.js"></script>
+  <script src="/static/viewer.js"></script>
+</body>
+</html>