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

semantic_code_review/viewer/assets/console_selection.ts

@@ -0,0 +1,102 @@
+// Console selection resolution — "ask about *this*".
+//
+// Slice 4 (ADR 0002): turn a browser text selection into a structured
+// hint the console can fold into a turn. We walk the selection's anchor
+// up the rendered diff DOM, reusing the same `.cell-lineno` / `.hunk` /
+// `.file` resolution the comment gutter uses (`comments.ts`), and
+// classify the selection as code / comment / plain:
+//
+//   - code    — inside a diff row; resolves to (file, side, hunk_id,
+//               line_range) so the server can inline the enclosing hunk.
+//   - comment — inside a reviewer/LLM annotation; carries just the text.
+//   - plain   — anything else (prose, the overview); carries just the text.
+//
+// Selections inside the console UI itself (the prompt, the drawer, the
+// footer) resolve to null so caret moves in the textarea don't register
+// as a pinned selection. This module is pure DOM → data; `console.ts`
+// owns the chip, the live tracking, and the wire payload.
+
+export interface ConsoleSelection {
+  selection_text: string;
+  selection_kind: "code" | "comment" | "plain";
+  file?: string;
+  side?: "old" | "new";
+  hunk_id?: string;
+  /** [start, end] line numbers on `side`, inclusive; collapsed to a
+   *  single line when the selection stays within one row. */
+  line_range?: [number, number];
+}
+
+/** The element a (possibly text) node lives in, for `.closest()` walks. */
+function elementOf(node: Node | null): Element | null {
+  if (!node) return null;
+  return node.nodeType === Node.ELEMENT_NODE
+    ? (node as Element)
+    : node.parentElement;
+}
+
+/** Resolve a node's enclosing diff row to its (side, line) — the same
+ *  shape `comments.ts` reads off `row.children[0]`. Null when the node
+ *  isn't in a numbered code row. */
+function rowLine(node: Node | null): { side: "old" | "new"; line: number } | null {
+  const row = elementOf(node)?.closest(".row");
+  if (!row) return null;
+  const cell = row.children[0] as HTMLElement | undefined;
+  if (!cell || !cell.classList.contains("cell-lineno")) return null;
+  if (cell.classList.contains("empty")) return null;
+  const side: "old" | "new" =
+    cell.classList.contains("cell-lineno-old") ? "old" : "new";
+  const line = parseInt((cell.textContent || "").trim(), 10);
+  if (isNaN(line)) return null;
+  return { side, line };
+}
+
+/** Resolve a live selection to a console hint, or null when there's
+ *  nothing usable (collapsed, empty, or inside the console UI). */
+export function resolveSelection(sel: Selection | null): ConsoleSelection | null {
+  if (!sel || sel.isCollapsed) return null;
+  const text = sel.toString().trim();
+  if (!text) return null;
+
+  const anchorEl = elementOf(sel.anchorNode);
+  if (!anchorEl) return { selection_text: text, selection_kind: "plain" };
+
+  // Ignore the console's own surfaces — a caret move in the prompt or a
+  // drag across the transcript isn't a selection of the change.
+  if (anchorEl.closest(".console-drawer, .console-input, #status-bar")) {
+    return null;
+  }
+
+  // Comment / annotation text — reviewer threads and LLM annotations.
+  if (anchorEl.closest(".comment-thread, .comment-editor-body, .row-annotation")) {
+    return { selection_text: text, selection_kind: "comment" };
+  }
+
+  // Code — must sit inside a diff row of a hunk in a file.
+  const hunkEl = anchorEl.closest(".hunk");
+  const fileEl = anchorEl.closest(".file");
+  const anchor = rowLine(sel.anchorNode);
+  if (hunkEl && fileEl && anchor) {
+    const hunk_id = hunkEl.getAttribute("data-id") || undefined;
+    const pathEl = fileEl.querySelector(".file-path");
+    const file = pathEl ? (pathEl.textContent || "").trim() : "";
+    // The focus row may differ from the anchor row on a multi-line drag;
+    // keep the range on the anchor's side and span the two line numbers.
+    const focus = rowLine(sel.focusNode);
+    const lines = [anchor.line];
+    if (focus && focus.side === anchor.side) lines.push(focus.line);
+    const lo = Math.min(...lines);
+    const hi = Math.max(...lines);
+    const out: ConsoleSelection = {
+      selection_text: text,
+      selection_kind: "code",
+      side: anchor.side,
+      line_range: [lo, hi],
+    };
+    if (file) out.file = file;
+    if (hunk_id) out.hunk_id = hunk_id;
+    return out;
+  }
+
+  return { selection_text: text, selection_kind: "plain" };
+}

semantic_code_review/viewer/assets/data_store.ts

@@ -0,0 +1,156 @@
+// Typed mutators for the viewer's in-memory [[viewer-data]] tree.
+//
+// Before this module existed, boot.ts owned a few hundred lines of
+// SSE-handler logic that walked DATA in place, mutated nested slots,
+// and silently augmented HunkBlock / FoldRegion with private
+// `_failed` / `_inflight` flags via local `... extends HunkBlock`
+// interfaces. The renderer and folds.ts independently re-declared
+// the same augmentations — three places, no shared contract.
+//
+// This module owns those mutations. boot.ts's SSE handlers shrink to
+// "translate payload into a DataStore call, then ask the right module
+// to repaint." The viewer-runtime fields (`_failed`, `_inflight`) are
+// now part of HunkBlock / FoldRegion in types.d.ts; DataStore is
+// their canonical writer.
+//
+// Functional API: every mutator takes the `ViewerData` reference as
+// its first argument. boot.ts still holds the reference (it owns the
+// `/data.json` fetch result); DataStore is stateless. That keeps the
+// existing pattern where Comments.init / Sidebar.init / Render.init
+// each receive the same reference and see mutations through it.
+
+export interface FoldRegionAddress {
+  file_idx: number;
+  context: FoldContext;
+  right_start: number;
+  right_end: number;
+  left_start: number;
+  left_end: number;
+}
+
+export interface ResolvedFoldRegion {
+  file: FileBlock;
+  /** Index into `file.hunks` of the hunk whose `fold_regions` list
+   *  carries the addressed region. Regions are addressed at the file
+   *  level but persisted on individual hunks (today, the first hunk
+   *  of the file — see CONTEXT.md `Fold region`). */
+  hostHunkIdx: number;
+  region: FoldRegion;
+}
+
+export type FoldSummaryResult = "applied" | "noop" | "inflight" | "not-found";
+
+export interface OverviewApplyResult {
+  /** True iff `payload.groups` was non-empty; tells boot.ts whether
+   *  to refresh the themes axis in addition to a full re-render. */
+  groupsChanged: boolean;
+}
+
+export const DataStore = {
+  // --- Overview / per-file metadata ----------------------------------
+
+  applyOverview(data: ViewerData, payload: SseOverviewEvent): OverviewApplyResult {
+    if (payload.pr) {
+      Object.assign(data.pr || (data.pr = {} as PRBlock), payload.pr);
+    }
+    if (Array.isArray(payload.files)) {
+      for (const fp of payload.files) {
+        const f = data.files && data.files[fp.file_idx];
+        if (!f) continue;
+        if (fp.summary !== undefined) f.summary = fp.summary;
+        if (fp.language) f.language = fp.language;
+        if (fp.symbols) f.symbols = fp.symbols;
+        if (fp.status) f.status = fp.status;
+      }
+    }
+    const groupsChanged = Array.isArray(payload.groups);
+    if (groupsChanged) {
+      data.groups = payload.groups!;
+    }
+    return { groupsChanged };
+  },
+
+  // --- Per-hunk replacement ------------------------------------------
+
+  /** Splice an augmented HunkBlock into the tree. Returns the file
+   *  whose hunk was replaced (so the caller can hand it to
+   *  Render.renderHunkReplace), or null if the address is invalid. */
+  replaceHunk(
+    data: ViewerData, file_idx: number, hunk_idx: number, block: HunkBlock,
+  ): FileBlock | null {
+    const file = data.files && data.files[file_idx];
+    if (!file || !file.hunks || !file.hunks[hunk_idx]) return null;
+    file.hunks[hunk_idx] = block;
+    return file;
+  },
+
+  /** Mark a hunk slot as failed: the renderer reads `_failed` to show
+   *  "couldn't produce annotations" instead of the pending spinner. */
+  markHunkFailed(
+    data: ViewerData, file_idx: number, hunk_idx: number,
+  ): FileBlock | null {
+    const file = data.files && data.files[file_idx];
+    if (!file || !file.hunks || !file.hunks[hunk_idx]) return null;
+    const hunk = file.hunks[hunk_idx];
+    hunk.intent = "";
+    hunk._failed = true;
+    return file;
+  },
+
+  // --- Fold regions --------------------------------------------------
+
+  /** Look up the fold region at `addr`, walking every hunk in the
+   *  addressed file. Returns null if no matching region exists. */
+  findFoldRegion(data: ViewerData, addr: FoldRegionAddress): ResolvedFoldRegion | null {
+    const f = data.files && data.files[addr.file_idx];
+    if (!f) return null;
+    for (let hi = 0; hi < (f.hunks || []).length; hi++) {
+      const h = f.hunks[hi];
+      for (const r of h.fold_regions || []) {
+        if (_foldKeyMatches(r, addr)) {
+          return { file: f, hostHunkIdx: hi, region: r };
+        }
+      }
+    }
+    return null;
+  },
+
+  /** Apply a server-side fold summary to the matching region.
+   *
+   *  Outcomes:
+   *    "applied"   — summary written; caller should re-render.
+   *    "noop"      — same summary already present; nothing to do.
+   *    "inflight"  — region's own local POST is racing this; caller
+   *                  must NOT re-render (the in-flight handler owns
+   *                  the DOM update, and a re-render would pop the
+   *                  user's just-closed fold back open).
+   *    "not-found" — the address doesn't match any region. */
+  applyFoldSummary(
+    data: ViewerData, addr: FoldRegionAddress, summary: string,
+  ): FoldSummaryResult {
+    const resolved = this.findFoldRegion(data, addr);
+    if (!resolved) return "not-found";
+    if (resolved.region.summary === summary) return "noop";
+    resolved.region.summary = summary;
+    if (resolved.region._inflight) return "inflight";
+    return "applied";
+  },
+
+  // --- Stream lifecycle ----------------------------------------------
+
+  finalisePending(data: ViewerData): void {
+    // Hunks the server never sent an event for (filtered, skipped,
+    // crashed mid-pass) now render the failure copy instead of the
+    // spinner on the next paint.
+    data.pending = false;
+  },
+};
+
+
+function _foldKeyMatches(r: FoldRegion, addr: FoldRegionAddress): boolean {
+  return (r.context || "right") === addr.context
+    && (r.right_start || 0) === addr.right_start
+    && (r.right_end || 0) === addr.right_end
+    && (r.left_start || 0) === addr.left_start
+    && (r.left_end || 0) === addr.left_end;
+}

semantic_code_review/viewer/assets/file_rows.ts

@@ -0,0 +1,49 @@
+// Typed handle from the renderer to the fold-detector for the per-file
+// row stream.
+//
+// Why this module exists. The fold detector (folds.ts) needs to walk
+// every row in a file — across hunks, across expanded gap-context — in
+// DOM order, with access to both the `RowBlock` records and the
+// per-side DOM elements those rows materialised into. The renderer
+// (render.ts) is the only place that has all three pieces at the
+// moment of construction.
+//
+// The previous shape stashed three optional properties (`_scrRows`,
+// `_scrRowElsOld`, `_scrRowElsNew`) directly on the `.diff` /
+// `.gap-expansion` HTMLElements via three independently-declared
+// HTMLElement augmentation interfaces. That worked, but the contract
+// was triplicated, stringly-typed, and silent: a rename on the
+// producing side broke the consuming side at runtime, not at compile
+// time.
+//
+// This module owns the contract instead. `record` is called by the
+// renderer for every `.diff` / `.gap-expansion` it builds; `get` is
+// called by the fold detector for each candidate container as it walks
+// `.file-body`. Storage is a `WeakMap` keyed by container reference,
+// so entries vanish when a container is replaced (collapsed back to a
+// chip, re-rendered after an SSE hunk replace, etc.).
+
+export interface RowWithEls extends RowBlock {
+  oldEl: HTMLElement;
+  newEl: HTMLElement;
+}
+
+export interface FileRowsEntry {
+  rows: RowBlock[];
+  oldEls: HTMLElement[];
+  newEls: HTMLElement[];
+}
+
+const _storage = new WeakMap<HTMLElement, FileRowsEntry>();
+
+export const FileRows = {
+  /** Record the row stream for a `.diff` or `.gap-expansion` container. */
+  record(container: HTMLElement, entry: FileRowsEntry): void {
+    _storage.set(container, entry);
+  },
+
+  /** Look up a container's recorded rows, or undefined if none was set. */
+  get(container: HTMLElement): FileRowsEntry | undefined {
+    return _storage.get(container);
+  },
+};