perf: benchmark and optimize large split review streams (#76)

* test: benchmark large split review streams

* test: flush benchmark highlight work

* Baseline note-enabled large split-stream scroll benchmark on PR branch before optimization; current 18-tick note-enabled scroll cost is 16406.23ms and still shows act warnings from deferred highlight work.\n\nResult: {"status":"keep","note_scroll_ticks_ms":16406.23}

* Scope visible agent notes to the selected hunk and keep placeholder windowing active for the rest of the review stream; note-enabled 18-tick scroll drops from 16406.23ms to 647.48ms while the interaction test now follows notes as focus moves.\n\nResult: {"status":"keep","note_scroll_ticks_ms":647.48}

* Count visible inline note rows in split-mode section metrics so placeholder windowing keeps accurate heights for the selected note-bearing file; note-enabled 18-tick scroll drops from 647.48ms to 231.25ms and the section-height helper now has note-row coverage.\n\nResult: {"status":"keep","note_scroll_ticks_ms":231.25}

* Validation rerun after note-height-aware windowing confirms the win: note-enabled 18-tick scroll improves further to 197.32ms, though the benchmark still occasionally surfaces deferred Pierre highlight act warnings that should be cleaned up separately.\n\nResult: {"status":"keep","note_scroll_ticks_ms":197.32}

* Baseline after restoring viewport-scoped visible notes rather than selected-hunk-only notes; under the broader visible-note policy the current 18-tick large-stream scroll cost is 2009.15ms.\n\nResult: {"status":"keep","note_scroll_ticks_ms":2009.15}

* Cache note-aware section metrics by visible note set so viewport-scoped visible notes reuse placeholder height plans across scroll ticks; under the restored always-visible note policy, the 18-tick large-stream scroll cost drops from 2009.15ms to 301.54ms while viewport-visible notes stay on screen.\n\nResult: {"status":"keep","note_scroll_ticks_ms":301.54}

* chore: remove autoresearch log

Author: benvinegar

.gitignore

@@ -40,3 +40,5 @@ tmp
 .hunk/latest.json
 .hunk/config.toml
 .pi/
+autoresearch.jsonl
+autoresearch.ideas.md

CONTRIBUTING.md

@@ -57,6 +57,17 @@ bun run build:npm
 bun run check:pack
 ```
 
+Benchmark scripts live in [`benchmarks/`](benchmarks/README.md).
+
+Common runs:
+
+```bash
+bun run bench:bootstrap-load
+bun run bench:highlight-prefetch
+bun run bench:large-stream
+bun run bench:large-stream-profile
+```
+
 Build and smoke-test the prebuilt npm packages for the current host:
 
 ```bash

benchmarks/README.md

@@ -0,0 +1,28 @@
+# Benchmarks
+
+Benchmark scripts, shared fixtures, and local result artifacts live here.
+
+## Scripts
+
+- `bootstrap-load.ts` — measures bootstrap and git-loader cost on a synthetic large repo
+- `highlight-prefetch.ts` — measures selected-file highlight startup and adjacent prefetch readiness
+- `large-stream.ts` — measures large split-stream first-frame and scroll cost, including note-enabled cases
+- `large-stream-profile.ts` — profiles the main pure planning stages behind the large split-stream benchmark
+- `large-stream-fixture.ts` — shared synthetic diff fixture used by the large-stream benchmarks
+
+## Running
+
+From the project root:
+
+```bash
+bun run bench:bootstrap-load
+bun run bench:highlight-prefetch
+bun run bench:large-stream
+bun run bench:large-stream-profile
+```
+
+## Results
+
+Use `benchmarks/results/` for local benchmark output, notes, or captured runs.
+
+The folder stays in the repo so the convention is discoverable, but local result files inside it are ignored by default.

test/bootstrap-load-benchmark.ts benchmarks/bootstrap-load.tstest/bootstrap-load-benchmark.ts renamed to benchmarks/bootstrap-load.ts

@@ -0,0 +1,122 @@
+import { parseDiffFromFile } from "@pierre/diffs";
+import type { AppBootstrap, DiffFile } from "../src/core/types";
+
+export const DEFAULT_FILE_COUNT = 180;
+export const DEFAULT_LINES_PER_FILE = 120;
+export const DEFAULT_NOTES_PER_FILE = 2;
+
+interface LargeSplitStreamFixtureOptions {
+  fileCount?: number;
+  linesPerFile?: number;
+  notesPerFile?: number;
+}
+
+function createAgentAnnotations(index: number, notesPerFile: number) {
+  if (notesPerFile <= 0) {
+    return [];
+  }
+
+  return Array.from({ length: notesPerFile }, (_, noteIndex) => {
+    const startLine = 40 + noteIndex * 12;
+    const endLine = startLine + 5;
+    return {
+      id: `note:${index}:${noteIndex}`,
+      newRange: [startLine, endLine] as [number, number],
+      summary: `Explain the split-mode refactor in file ${index}, hunk note ${noteIndex + 1}.`,
+      rationale:
+        "Synthetic benchmark note to exercise inline note placement, guide rows, and note-enabled full-stream rendering.",
+    };
+  });
+}
+
+export function createLargeSplitDiffFile(
+  index: number,
+  {
+    linesPerFile = DEFAULT_LINES_PER_FILE,
+    notesPerFile = 0,
+  }: Omit<LargeSplitStreamFixtureOptions, "fileCount"> = {},
+): DiffFile {
+  const path = `src/stream${index}.ts`;
+  const before = Array.from({ length: linesPerFile }, (_, lineIndex) => {
+    const line = lineIndex + 1;
+    return `export function stream${index}_${line}(value: number) { return value + ${line}; }\n`;
+  }).join("");
+
+  const after = Array.from({ length: linesPerFile }, (_, lineIndex) => {
+    const line = lineIndex + 1;
+    if (lineIndex >= 36 && lineIndex < 84) {
+      return `export function stream${index}_${line}(value: number) { return value * ${line} + ${index}; }\n`;
+    }
+
+    return `export function stream${index}_${line}(value: number) { return value + ${line}; }\n`;
+  }).join("");
+
+  const metadata = parseDiffFromFile(
+    {
+      name: path,
+      contents: before,
+      cacheKey: `stream:${index}:before:${linesPerFile}`,
+    },
+    {
+      name: path,
+      contents: after,
+      cacheKey: `stream:${index}:after:${linesPerFile}`,
+    },
+    { context: 3 },
+    true,
+  );
+
+  const annotations = createAgentAnnotations(index, notesPerFile);
+
+  return {
+    id: `stream:${index}`,
+    path,
+    patch: "",
+    language: "typescript",
+    stats: { additions: 48, deletions: 48 },
+    metadata,
+    agent:
+      annotations.length > 0
+        ? {
+            path,
+            summary: `Synthetic note-heavy benchmark context for ${path}`,
+            annotations,
+          }
+        : null,
+  };
+}
+
+export function createLargeSplitStreamFiles({
+  fileCount = DEFAULT_FILE_COUNT,
+  linesPerFile = DEFAULT_LINES_PER_FILE,
+  notesPerFile = 0,
+}: LargeSplitStreamFixtureOptions = {}) {
+  return Array.from({ length: fileCount }, (_, index) =>
+    createLargeSplitDiffFile(index + 1, { linesPerFile, notesPerFile }),
+  );
+}
+
+export function createLargeSplitStreamBootstrap({
+  fileCount = DEFAULT_FILE_COUNT,
+  linesPerFile = DEFAULT_LINES_PER_FILE,
+  notesPerFile = 0,
+}: LargeSplitStreamFixtureOptions = {}): AppBootstrap {
+  return {
+    input: {
+      kind: "git",
+      staged: false,
+      options: {
+        mode: "auto",
+      },
+    },
+    changeset: {
+      id: `changeset:large-split-stream:${fileCount}:${linesPerFile}:${notesPerFile}`,
+      sourceLabel: "repo",
+      title: "repo working tree",
+      files: createLargeSplitStreamFiles({ fileCount, linesPerFile, notesPerFile }),
+    },
+    initialMode: "split",
+    initialTheme: "midnight",
+    initialShowAgentNotes: notesPerFile > 0,
+  };
+}

…adjacent-highlight-prefetch-benchmark.ts benchmarks/highlight-prefetch.tstest/adjacent-highlight-prefetch-benchmark.ts renamed to benchmarks/highlight-prefetch.ts test/adjacent-highlight-prefetch-benchmark.ts renamed to benchmarks/highlight-prefetch.ts

@@ -0,0 +1,66 @@
+// Profile large split-mode review streams by timing the main pure planning stages
+// before the React tree and renderer get involved.
+import { performance } from "perf_hooks";
+import { buildSplitRows } from "../src/ui/diff/pierre";
+import { buildReviewRenderPlan } from "../src/ui/diff/reviewRenderPlan";
+import { measureDiffSectionMetrics } from "../src/ui/lib/sectionHeights";
+import { resolveTheme } from "../src/ui/themes";
+import {
+  createLargeSplitStreamFiles,
+  DEFAULT_FILE_COUNT,
+  DEFAULT_LINES_PER_FILE,
+  DEFAULT_NOTES_PER_FILE,
+} from "./large-stream-fixture";
+
+const theme = resolveTheme("midnight", null);
+const windowedFiles = createLargeSplitStreamFiles({ notesPerFile: 0 });
+const noteFiles = createLargeSplitStreamFiles({ notesPerFile: DEFAULT_NOTES_PER_FILE });
+
+function visibleAgentNotesForFile(file: (typeof noteFiles)[number]) {
+  const annotations = file.agent?.annotations ?? [];
+  return annotations.map((annotation, index) => ({
+    id: `annotation:${file.id}:${annotation.id ?? index}`,
+    annotation,
+  }));
+}
+
+function measureMs(run: () => void) {
+  const start = performance.now();
+  run();
+  return performance.now() - start;
+}
+
+const sectionMetricsMs = measureMs(() => {
+  windowedFiles.forEach((file) => {
+    measureDiffSectionMetrics(file, "split", true, theme);
+  });
+});
+
+let windowedRows = 0;
+const splitRowsMs = measureMs(() => {
+  windowedFiles.forEach((file) => {
+    windowedRows += buildSplitRows(file, null, theme).length;
+  });
+});
+
+let notePlannedRows = 0;
+const noteReviewPlanMs = measureMs(() => {
+  noteFiles.forEach((file) => {
+    const rows = buildSplitRows(file, null, theme);
+    notePlannedRows += buildReviewRenderPlan({
+      fileId: file.id,
+      rows,
+      showHunkHeaders: true,
+      visibleAgentNotes: visibleAgentNotesForFile(file),
+    }).length;
+  });
+});
+
+console.log(`METRIC section_metrics_ms=${sectionMetricsMs.toFixed(2)}`);
+console.log(`METRIC split_rows_ms=${splitRowsMs.toFixed(2)}`);
+console.log(`METRIC note_review_plan_ms=${noteReviewPlanMs.toFixed(2)}`);
+console.log(`METRIC split_rows=${windowedRows}`);
+console.log(`METRIC note_planned_rows=${notePlannedRows}`);
+console.log(`METRIC files=${DEFAULT_FILE_COUNT}`);
+console.log(`METRIC lines_per_file=${DEFAULT_LINES_PER_FILE}`);
+console.log(`METRIC notes_per_file=${DEFAULT_NOTES_PER_FILE}`);

benchmarks/large-stream-fixture.ts

@@ -0,0 +1,129 @@
+// Benchmark split-mode startup and scroll behaviour on very large review streams,
+// including note-enabled cases that disable the placeholder windowing path.
+import { performance } from "perf_hooks";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import { App } from "../src/ui/App";
+import {
+  createLargeSplitStreamBootstrap,
+  DEFAULT_FILE_COUNT,
+  DEFAULT_LINES_PER_FILE,
+  DEFAULT_NOTES_PER_FILE,
+} from "./large-stream-fixture";
+
+const VIEWPORT = {
+  width: 240,
+  height: 28,
+} as const;
+const SCROLL_TICKS = 18;
+const SCROLL_TARGET = {
+  x: 170,
+  y: 12,
+} as const;
+const SELECTED_HIGHLIGHT_MARKER = "stream1_40";
+
+type BenchmarkRenderer = Awaited<ReturnType<typeof testRender>>;
+
+function frameHasHighlightedMarker(
+  frame: { lines: Array<{ spans: Array<{ text: string }> }> },
+  marker: string,
+) {
+  return frame.lines.some((line) => {
+    const text = line.spans.map((span) => span.text).join("");
+
+    if (!text.includes(marker)) {
+      return false;
+    }
+
+    return line.spans.some(
+      (span) => span.text.includes(marker) && span.text.trim().length < text.trim().length,
+    );
+  });
+}
+
+async function renderPass(setup: BenchmarkRenderer, passes = 1) {
+  for (let index = 0; index < passes; index += 1) {
+    await act(async () => {
+      await setup.renderOnce();
+      await Bun.sleep(0);
+    });
+  }
+}
+
+async function flushSelectedHighlight(setup: BenchmarkRenderer) {
+  for (let iteration = 0; iteration < 200; iteration += 1) {
+    await renderPass(setup);
+
+    if (frameHasHighlightedMarker(setup.captureSpans(), SELECTED_HIGHLIGHT_MARKER)) {
+      return;
+    }
+  }
+}
+
+async function destroyRenderer(setup: BenchmarkRenderer) {
+  await act(async () => {
+    setup.renderer.destroy();
+  });
+}
+
+async function measureFirstFrameMs(notesPerFile: number) {
+  const setup = await testRender(
+    React.createElement(App, {
+      bootstrap: createLargeSplitStreamBootstrap({ notesPerFile }),
+    }),
+    VIEWPORT,
+  );
+  const start = performance.now();
+
+  try {
+    await renderPass(setup);
+    return performance.now() - start;
+  } finally {
+    await flushSelectedHighlight(setup);
+    await destroyRenderer(setup);
+  }
+}
+
+async function measureScrollTicksMs(notesPerFile: number) {
+  const setup = await testRender(
+    React.createElement(App, {
+      bootstrap: createLargeSplitStreamBootstrap({ notesPerFile }),
+    }),
+    VIEWPORT,
+  );
+
+  try {
+    await renderPass(setup, 2);
+    const start = performance.now();
+
+    for (let index = 0; index < SCROLL_TICKS; index += 1) {
+      await act(async () => {
+        await setup.mockMouse.scroll(SCROLL_TARGET.x, SCROLL_TARGET.y, "down");
+        await setup.renderOnce();
+        await Bun.sleep(0);
+      });
+    }
+
+    return performance.now() - start;
+  } finally {
+    await flushSelectedHighlight(setup);
+    await destroyRenderer(setup);
+  }
+}
+
+const coldFirstFrameMs = await measureFirstFrameMs(0);
+const warmFirstFrameMs = await measureFirstFrameMs(0);
+const noteFirstFrameMs = await measureFirstFrameMs(DEFAULT_NOTES_PER_FILE);
+const windowedScrollMs = await measureScrollTicksMs(0);
+const noteScrollMs = await measureScrollTicksMs(DEFAULT_NOTES_PER_FILE);
+
+console.log(`METRIC cold_first_frame_ms=${coldFirstFrameMs.toFixed(2)}`);
+console.log(`METRIC warm_first_frame_ms=${warmFirstFrameMs.toFixed(2)}`);
+console.log(`METRIC note_first_frame_ms=${noteFirstFrameMs.toFixed(2)}`);
+console.log(`METRIC windowed_scroll_ticks_ms=${windowedScrollMs.toFixed(2)}`);
+console.log(`METRIC note_scroll_ticks_ms=${noteScrollMs.toFixed(2)}`);
+console.log(`METRIC scroll_ticks=${SCROLL_TICKS}`);
+console.log(`METRIC files=${DEFAULT_FILE_COUNT}`);
+console.log(`METRIC lines_per_file=${DEFAULT_LINES_PER_FILE}`);
+console.log(`METRIC notes_per_file=${DEFAULT_NOTES_PER_FILE}`);

benchmarks/large-stream-profile.ts

@@ -0,0 +1,3 @@
+*
+!.gitignore
+!.gitkeep