18 Commits

Author	SHA1	Message	Date
Michael Ramos	4465950f0c	feat: add bounded annotation undo and redo (#1426) ... * feat: add bounded undo and redo history * fix: address undo redo review feedback * chore: refresh guide viewer manifest * fix undo history review regressions * chore: refresh guide viewer manifest	2026-08-31 09:12:13 -07:00
Michael Ramos	15f8d4fe4c	feat(review): collapse generated files by default in the all-files view (#1346) ... * feat(review): collapse linguist-generated files by default (#1317) Code review now respects linguist-generated (and linguist-generated=true) from .gitattributes, collapsing those diffs by default the way GitHub does. Server (Bun + Pi mirror): a generatedFiles sidecar rides /api/diff and /api/diff/switch, resolved through git's own attribute machinery — one batched 'git check-attr --stdin -z' over the served patch's paths at the review cwd, so stacked and negated rules land exactly as git resolves them. Plain local git sessions only; PR worktrees, workspace multi-repo, jj, GitButler, and P4 omit the sidecar (degrade to no-collapse). Shared logic in packages/shared/generated-files.ts, vendored to Pi. Client: generated files SEED their CodeView item collapsed (the existing Pierre collapse state — same mechanism as commit-diff folding), render the one-line FileHeader bar with a 'generated' tag next to the +/- counts, and expand per file on click. Expansion is session-local App state so it survives remounts and diff switches. Presentation-only: the diff data, annotations, search, and Edit Mode are untouched; the file tree and single-file tabs list generated files normally (tag, no auto-collapse). Guide viewer manifest pin regenerated (AllFilesCodeView/FileHeader are bundled into the guides.show viewer) from a clean frozen-lockfile install. * feat(review): built-in generated defaults, visible collapsed strip, review-round fixes (#1317) Round 2 on PR #1346, per maintainer review. Built-in generated defaults (industry-standard two-layer detection): packages/shared/generated-files.ts (vendored to Pi) now carries DEFAULT_GENERATED_PATTERNS — lockfiles (package-lock.json, yarn.lock, bun.lock, Cargo.lock, go.sum, ...) plus *.min.js / *.min.css / *.map — matched against the path's last segment only. Explicit .gitattributes wins in BOTH directions: linguist-generated (set/true) marks any file, -linguist-generated / =false un-marks even a built-in name, unspecified falls through to the defaults. In plain local git sessions check-attr refines the defaults; the non-git degrade modes (piped patches, PR worktrees, workspace, jj, GitButler, P4) now emit the sidecar from the name-based defaults alone instead of omitting it. Visible collapsed state: a collapsed generated card no longer renders as a bare header — a GeneratedFileNotice strip ('Generated file collapsed', +N/-N, 'Click to view') styled like the other below-header notices sits in the card, and clicking it expands through the SAME reportFileCollapsed funnel as the chevron. Review findings: - F1: search-match and sidebar-comment navigation expanded items without reporting through the funnel, so those expansions died on diff switch. Both now call syncAllCollapsedMirror + reportFileCollapsed; the funnel invariant comment lists the navigation-driven sites. - F2: the check-attr call gets the same 5000ms timeout as review-core's stdin git callers, and Pi's vcs.ts stdin write gets the one-line EPIPE guard (call-flow.ts shape) a timeout kill makes reachable. - F3: removed the dead prevGeneratedRef + collectSetDelta leg — a changed generated set always remounts via fileSetKey, so the delta path was unreachable. Tests: default-list matching (glob + directory-named-bun.lock), both- direction precedence, non-git sidecar from defaults (dual-runtime), the placeholder strip through the funnel, and search expansion surviving a re-seed round-trip. AGENTS.md payload docs updated. Guide viewer manifest pin regenerated from this clean frozen-lockfile worktree.	2026-08-17 23:32:29 -07:00
Michael Ramos	d0c32c8863	fix(review): preserve dragged diff ranges on compact touch before commenting (#1333) ... * feat: add mobile touch range selection prototypes * docs: redirect mobile range selection spike * revert: remove command-mediated touch range prototype * docs: align mobile line selection with DiffsHub * feat: preserve mobile diff ranges before commenting * fix(review): repaint a preserved mobile range on a second drag A preserved range leaves pendingSelection non-null, so DiffViewer hands Pierre a defined selectedLines and Pierre switches to controlled selection: updateSelection then only records a proposed range and leaves painting to the host. With no change handler wired, a second drag never repainted, so the old highlight stayed put and the finger was untracked until release. Wire onLineSelectionChange back into app state, only on compact touch, so desktop keeps an options object with no such key. Also route a null range to the toolbar host instead of swallowing it in the preserve branch, mirroring AllFilesCodeView's early return so an open composer (Ask AI included) closes with the selection it was written for. * fix(review): 44px hit area for Pierre's gutter comment button on touch With a dragged range now preserved instead of opening the composer, that button is the only way to start writing about it, and it is roughly 20px square: below the data-pn-touch-target standard the rest of the compact shell holds. Grow its invisible ::before hit area to the 44px token, leaving the glyph alone. The rule ships through the same unsafeCSS both diff surfaces already inject, which lands in Pierre's shadow root inside @layer unsafe (last in the library's layer order, so no !important). It is injected only when the shell is compact rather than gated in CSS: html:has() matches nothing from inside a shadow root, and @media (pointer: coarse) would wrongly claim a desktop with a touchscreen. * test(review): cover the compact-touch preserved range on both diff surfaces DiffViewer.compactTouchSelection.test.tsx drives the FileDiff options the component hands Pierre: a drag preserves the range instead of opening the composer and paints it through selectedLines, a second drag repaints through onLineSelectionChange, the gutter action opens the composer, a cleared range still reaches the toolbar host, and desktop keeps routing completed drags straight to the composer with no change handler at all. The last three assertions fail against the pre-fix component. The AllFilesCodeView compact test only checked what was published upward, which a range nothing paints would also satisfy; it now asserts the range reaches the CodeView props. That needs the App loop, so the mount feeds published selections back down as pendingSelection: without it the reconcile effect clears the highlight the preserve branch just painted. * chore(guides-show): regenerate viewer manifest pin for the touch selection changes	2026-08-16 21:47:43 -07:00
Michael Ramos	64062af9a1	feat: Portable Guided Reviews — export, share links, agent-authored guides, guides.show (#1324) ... A Guided Review can now leave Plannotator: as a single self-contained HTML file that renders exactly like the in-app guide, as an encrypted-by-default share link on guides.show, or authored by any agent through the new guide CLI. Highlights: packages/guide-viewer extracted from review-editor at the injection seam (read-only host, no third renderer); guides.show Worker with R2-backed share storage, per-IP rate limiting on creation, delete tokens hashed at rest, and 128-bit ids; portable exports pin the viewer by SRI hash with budget and manifest gates in PR CI and at deploy; two-runtime parity across Bun and Pi verified; v0.27.x saved guides load unchanged. Retention is indefinite by explicit decision, to revisit with the lean sharing refactor. Decision record: adr/decisions/007-portable-guided-reviews-20260815.md	2026-08-16 12:17:13 -07:00
Michael Ramos	64e3fa7762	feat(review): add compact touch review shell (#1301) ... * feat(review): add compact touch review shell * fix(review): let submission dialog own initial focus * fix(review): refine compact mobile review chrome * fix(review): restore reliable mobile diff scrolling * fix(review): preserve mobile file identity * docs(mobile): specify phase 2b plan shell * fix(review): close mobile shell regressions * fix(review): restore narrow overview stacking * test(review): preserve real syntax theme resolver	2026-08-13 09:29:24 -07:00
Michael Ramos	3282be673b	fix(review): hide viewed and stage controls in file headers when toggled off (#1288)	2026-08-12 17:06:19 -07:00
Michael Ramos	75e8b78cc7	fix(review): stop stubbing files whose worktree content the size probe cannot find (#1220) ... The oversized preflight in buildBoundedTrackedDiff mapped every object the cat-file batch could not size to infinity. `missing` is routine: for tree-vs-worktree diffs git hashes the WORKING-TREE content of any path pulled into rename/copy detection and prints that hash in --raw output without ever writing the blob, and partial clones report it for unfetched blobs. Those files were excluded by pathspec and replaced with a contents-free binary stub, so a renamed-and-edited file rendered as a silently empty card and /api/file-content refused it as binary. Missing now means unknown, not oversized, and an unreadable new side is bounded by the working-tree file's stat size instead. Every rendered diff stays bounded git-side by core.bigFileThreshold (#1205), genuinely oversized files still stub via real probe sizes plus the stat door, and a blob git truly cannot read now fails loudly through assertGitSuccess instead of blanking a file. Client side, a chunk with a binary marker and no hunks now renders an explicit placeholder in both the all-files view and the single-file viewer, so an empty card can never again pass for "no changes here". AI-assisted.	2026-08-06 00:47:19 -07:00
Michael Ramos	7ba4e3b3e4	fix(review): mint content-derived diff cache keys so single-file tabs render fully (#1219) ... * fix(review): mint content-derived diff cache keys so single-file tabs render fully Single-file diff tabs have not rendered their full-content diff since v0.26.0: the expansion gap bars show no chevrons and clicking them does nothing, at every file size. @pierre/diffs 1.3.2 (the 1.2.8 -> 1.3.2 bump, upstream "Fix diff rerender in edit mode (#878)") added name-based cacheKey defaulting in FileDiff.render: an unset `fileDiff.cacheKey` becomes the file's name. `areDiffTargetsEqual` — the only identity check its render and highlight caches make — compares nothing but that key. DiffViewer renders each file twice on one surviving FileDiff instance (key={filePath}): first the PARTIAL diff from getSingularPatch, then the AUGMENTED full-content diff from processFile once /api/file-content lands. Neither set a cacheKey, so both defaulted to the filename and Pierre served the stale partial render forever. Only the augmented diff is expandable, hence the dead gap bars. Both diffs now mint content-derived keys (`<path>#<hash>` and `<path>#full#<hash>`), matching how AllFilesCodeView already keys its items — which is why the all-files view was never affected. The hash (not patch.length) matters because Pierre's worker highlight cache is a singleton that outlives remounts. The partial diff needs its own key too: with key={filePath} the instance also survives diff-type and base switches, where a same-named new patch would otherwise hit the same name-keyed stale cache. hashString moves from AllFilesCodeView to utils/hashString.ts so both surfaces mint keys the same way. Covered by a new DOM test that mounts DiffViewer against the real @pierre/diffs renderer, holds the /api/file-content response until the non-expandable partial baseline is asserted, then requires the expansion affordances to reach the pixels. It fails against the unfixed tree. * fix(review): explain why an oversized file's card has no diff Files over the 5 MB review limit are replaced by a contents-free stub (buildOversizedTrackedStub, plus the untracked equivalent), which renders as a header-only card with no counts and no explanation. Users read that as a broken diff. The stub now carries an explicit marker line in its extended header (OVERSIZED_REVIEW_STUB_MARKER). A marker rather than a client heuristic because the only other signal, `Binary files ... differ`, is exactly what a genuine binary file emits, so a heuristic would put a false size-cap explanation on every image in the diff. The marker lives in shared/diff-paths so the browser bundle can detect it without pulling in the node-facing review core; both server runtimes pick it up from review-core, which vendor.sh already copies to Pi. Git ignores unknown extended-header lines and @pierre/diffs parses the stub identically with or without it, so nothing else moves. Which files get stubbed is unchanged. Both review surfaces now render one line under the file header saying the file is over the limit and only a stub is shown. * test(review): make the diff-swap proof machine independent, not stopwatch based CI failed two tests that pass locally. Both were timing races, neither was an app bug. 1. DiffViewer.fullContentSwap: the swap assertion carried a 15s internal wall-clock budget, which a cold, contended CI runner blows and a warm laptop clears. Two changes, both aimed at the clock rather than the symptom: - The waits are now budgeted in SCHEDULER TURNS, not milliseconds. A slower box spends longer inside each turn but needs no more of them, so the budget never has to be retuned for CI hardware. - Pierre's shared Shiki highlighter is preloaded before mounting. It is a module singleton, and building it was the entire multi-second cost the old budget was accidentally measuring; warming it moves that work into an unbounded await OUTSIDE the observed window. Disposed in afterAll, because packages/ui/utils/codeHighlight.test.ts asserts the pre-attachment behaviour of that same singleton. Verified against an artificially stalled clock: forcing 20s of dead time into every wait (41s total, far past the old 15s budget) still passes, and with the cacheKey fix removed it still fails on the assertion (not as an opaque timeout) in ~12s. A 20-turn budget with the preload removed and every core saturated also passed 10/10, so 400 turns is a wide margin rather than a guess. 2. App.archiveReadOnly compared the fenced block's innerHTML before and after a click. Since #1218, applyHighlight writes plain text first and swaps in Shiki markup when the grammar attaches, so that MARKUP changes on its own schedule and the assertion was racing the swap. The test is checking that the click opened no mutation entry point, which textContent plus the absence of an annotation <mark> says exactly, and which no highlight swap can perturb. Latent on main; the branch's run happened to lose the race. Also fixed while confirming the above: codeHighlight.test.ts asserted a GLOBAL precondition ("no grammar attached yet") that any earlier file attaching a typescript fence invalidates, so `DOM_TESTS=1 bun test packages/ui packages/editor` failed by file order alone. It now resets the attachment cache through the existing __resetCodeHighlightCacheForTests seam and asserts the contract instead of the run order. Not currently reachable from CI (that file is not in the DOM list), but one list edit away. * test(review): drop the highlighter preload, harden the swap proof, report why a paint is missing The preload added in the previous commit made CI strictly worse, so it is gone. Before it, CI's partial diff painted and only the swap was missing; with it, CI never painted at all. It was an optimization for a theory the evidence has since killed, and it mutated a process-wide singleton to buy it, so it is not worth keeping while the real failure is unexplained. The afterAll dispose that existed only to undo the preload goes with it. What the CI log actually shows: - The "WorkerPoolManager: operation canceled because the pool terminated" error is inside discardRestoreRender.test.tsx's own group, ~0.3s BEFORE this file's group opens. It is that file's provider unmounting and terminating the pool singleton it created: end-of-file teardown, the same benign noise documented on #1209. It also prints on every local run, where the whole list passes. It is not a mid-test terminator, and nothing in this file uses the worker pool (no WorkerPoolContextProvider is mounted, so useWorkerPool() is undefined and rendering takes the main-thread path). - This file's group prints NOTHING for its whole 10.3s: no console.warn from the stale-content guard, no error. Pierre simply painted nothing. Not reproducible locally: the exact DOM list from test.yml, one bun process, forward and reverse order, 13 runs with every core saturated, all green. So the remaining difference is the environment, which cannot be reasoned out from here. Three changes make the next CI run answer it instead of costing another guess: - renderDiagnostics() dumps what Pierre actually painted (container / separator / chevron / line-number counts plus a markup fragment) when a wait gives up. Prints only on failure, so it is worth keeping. - The precondition is asserted rather than assumed: the REAL getSingularPatch and processFile must produce partial-then-full on these fixtures. Bun's mock.module is process global and an earlier file in this very list mocks '@pierre/diffs', so a leaked mock now fails in milliseconds with a clear message instead of as a render that never arrives. - The first paint is now REPORTED, not asserted. The verdict belongs to the swap; gating on the partial paint let a slow or absent first paint mask the result the test exists for. Removing the cacheKey fix still fails it (verified), because that tree paints no chevrons at any point. Also fixed a real trap in the fixture: the hunk header said @@ -61 while its context lines start at line 59 of both contents. Pierre realigns a misaligned header rather than rejecting it, so it was silently tolerated. * test(review): stop a leaked module mock from silently unrendering the diff tests Root cause, and it was never a timing problem. AllFilesCodeView.lifecycle.test.tsx calls `mock.module('@pierre/diffs', ...)` with a hunk-less `getSingularPatch` and `processFile: () => null`. Bun's module mocks are process global and are not unwound at file boundaries, and that file sits immediately before DiffViewer.fullContentSwap.test.tsx in the DOM step's list. On the Linux runner the stub reached this file; on macOS it did not, which is why 13 local runs of the exact list, both orders, cores saturated, stayed green. It explains both CI symptoms exactly, including the one that looked like a contradiction: `processFile: () => null` means the augmented diff never exists, so no chevrons ever (the failure before the preload); the stub `getSingularPatch` has `hunks: []`, so nothing paints at all (the failure after it). The "WorkerPoolManager: operation canceled because the pool terminated" line was a red herring throughout: it is inside discardRestoreRender's own group, ~0.3s BEFORE this file's group opens, is that file's provider unmounting the pool it created, and prints on every local run too. The precondition assertion added in the previous commit is what proved it, turning a 10.3s mystery into a 0.45ms verdict: 228 | expect(expected?.isPartial).toBe(false); error: expect(received).toBe(expected) Expected: false Received: undefined Fixed at both ends: - Source: the mocking file now captures the real modules before it stubs them and restores both library specifiers in afterAll, so no later file in any run inherits its stubs. This fixes the class for every future DOM test that needs the real renderer, which was the actual leak. - Consumer: the two tests that render against the real @pierre/diffs get their own CI step, the same isolation (and for the same kind of reason) this workflow already gives useFileBrowser.test.tsx. They are removed from the shared list so that step is their single source of truth. The restore above should make this unnecessary; it is not something to bet a green build on from a machine that cannot reproduce the platform behaviour. Verified with a CI-faithful harness: one bun process per step, the exact lists from test.yml, isolated + shared-forward + shared-reverse, 10 iterations with every core saturated, then 6 more after the final split. All green, plus the full suite and typecheck. * docs(test): point the diff-renderer DOM tests at the CI step that actually runs them	2026-08-06 00:31:25 -07:00
Michael Ramos	156761a3fa	feat(review): author suggestions by editing code in place (experimental, flag-gated) (#1193) ... * feat(ui): add experimental editSuggestions setting (cookie-only, default off) Registers the flag in the settings registry and surfaces it under a new Experimental section of the review Display tab. Not synced to server config while experimental; when off, no edit UI renders anywhere. * feat(review): edit-to-suggestion core (adapter wall, derivation, session controller) pierreEditAdapter.ts is the single module allowed to reference @pierre/diffs/edit: the editor chunk loads via dynamic import on first use, types are derived structurally, and the EditProvider factory declines attaches until the module is ready (CodeView retries). deriveSuggestions.ts diffs the session's final contents against the pre-edit new-side content with the diff package and emits one minimal hunk per contiguous changed region, expanding pure inserts/deletes to include an unchanged anchor line so originalCode and suggestedCode stay non-empty. CRLF input is normalized. cloneDiff.ts deep-clones FileDiffMetadata before a session starts; Pierre's editor mutates it in place (additionLines, hunks, editSessionDirty), and the clone is what gets republished when the session ends. useEditSession.ts owns the lifecycle: one file at a time, full-content hydration before entry (partial diffs throw in applyDocumentChange), suggestion creation on completion, and session end as ONE combined item write (edit off plus restored pristine fileDiff with a fresh cacheKey), which is upstream's documented commit pattern and avoids racing CodeView's teardown re-render. persistState is deliberately unused (upstream bug, open PR #1048). Existing annotations are projected to editor severity markers best-effort via onAttach. * feat(review): wire edit-to-suggestion into the plain all-files view (flag-gated) The plain all-files dock panel is the only surface that opts in; Guided Review deliberately stays off because its viewport manager evicts CodeViews beyond ~8 mounted, which would destroy an active editor session. When the flag is off the surface renders byte-identical to before: no EditProvider, no edit props, no header buttons. FileHeader gains the Edit entry button (disabled with a tooltip when content cannot be fetched) and the in-session Editing badge with Suggest/Discard controls. Slot portals republish before React commits state, so header rendering reads the session refs, not state. AllFilesCodeView routes every collapse path through finishIfEditing so a collapse ends the session on our one code path, blocks the annotation toolbar and augmentation applies for the file being edited, and drops session state on fileSetKey remounts (diff switches are user-initiated; in-progress edits are discarded, documented v1 behavior). App.tsx converts derived hunks into ordinary suggestion annotations (type comment with suggestedCode/originalCode, side new, anchored to new-side line numbers), the same shape SuggestionModal produces, so rendering, sidebar, drafts, and feedback export work unchanged. The browser never writes files; the agent applies suggestions. * test(review): cover edit-to-suggestion derivation, clone invariant, adapter wall, and flag-off UI deriveSuggestions: no-op edit, single and multi region edits, whole-line add and delete with anchor expansion, insertion at file start, file emptied, CRLF vs LF, trailing newline. cloneDiff: pristine clone stays byte-identical after the live object is mutated the way Pierre's edit session mutates it. adapterWall: only pierreEditAdapter.ts may reference @pierre/diffs/edit, and only via import type or dynamic import. FileHeader DOM tests (DOM_TESTS=1): zero edit UI without the feature, entry button, disabled tooltip, and the Suggest/Discard session controls; registered in test.yml's DOM step. * fix(review): resolve anchor collisions in suggestion derivation deriveSuggestionHunks could emit overlapping hunks when adjacent regions claimed the same anchor line (a file-start region expanding forward into a line the next region's backward expansion also claimed). An agent applying the suggestions against original line numbers would silently drop one or duplicate code. Regions are now emitted left to right with collision-aware anchoring: backward expansion is preferred but only when the preceding line is not already claimed by the previous hunk; otherwise the region anchors forward (always an unchanged line, and later regions see it as claimed); when both directions are unavailable (previous hunk adjacent and region runs to end of file) the region merges into the previous hunk as one spanning suggestion. A defensive fold enforces the non-overlap invariant (lineStart > previous lineEnd) as a safety net. Tests: unit cases for both reproduced collision shapes plus adjacent regions at file start and end, and a 5000-case seeded fuzz asserting zero overlaps, exact originalCode anchors, and full reconstruction of the edited text under a sequential offset-tracking applier. A 20,000-case run of the same generator reports zero overlaps, zero anchor mismatches, and zero round-trip failures. * feat(review): export originalCode as a Replaces block in feedback Suggestions carried originalCode internally but the export never emitted it, so the applying agent had no way to validate an anchor before applying. Each suggestion now exports a fenced Replaces block (the exact current lines being swapped out) ahead of the existing Suggested code block, for both line and file scoped annotations. SuggestionModal-authored and edit-session-derived suggestions flow through the same single format. A deletion-only suggestion (no suggestedCode) still emits its Replaces block so the anchor stays verifiable. Tests assert the block pairing per annotation, the deletion-only case, and that annotations without originalCode are unchanged. * fix(review): never silently discard a dirty edit session on file-set change fileSetKey changes on sort-order and collapse-default flips as well as diff switches and refreshes, and the remount tears the editor down without a completion callback. A dirty session was dropped silently there, destroying in-progress work, while the file-switch path prompted. The session now keeps the FileContents delivered with each change event (its contents getter is lazy and stays readable after editor cleanup), and handleFileSetChange recovers the last-known document text, derives the suggestions, and prompts to keep them, matching the dirty file-switch pattern. The call site is a post-commit effect, so the synchronous confirm is safe. Declining discards; a clean session or a no-op edit still drops without a prompt. New DOM-gated test (registered in test.yml's DOM step) covers the confirm, decline, clean, and no-op paths through the real hook, plus non-DOM units for the pure recovery helper. * fix(review): give editor markers real range width so they render Single-line annotation markers were projected as collapsed ranges (start and end both at character 0 of the same line); upstream's overlay renderer skips zero-width blocks, so markers never painted. Marker ranges now end at character 0 of the line after the last annotated line (exclusive-end LSP form), covering every annotated line in full; the editor's TextDocument clamps a past-the-end position back to end-of-document. Verified via CDP against a live review server: the severity squiggle renders across the annotated line during an active edit session and the hover popover shows the annotation source and message. Also corrects overstating comments: the flag-off claim that the editor module is never imported (the single-file build inlines dynamic imports, so the namespace exists at page load but stays inert) and the createEditor decline-and-retry framing (the React wrapper throws on an undefined return; the controller awaits the chunk before any item enters edit mode, and onAttach delivers once per editor rather than re-firing across virtualization re-attaches). * polish: drop suggestion card left accent, move Edit to far right of file header Suggestion cards keep the colored SUGGESTION header as their sole identity marker; the green left border on the card body is removed for all suggestion cards (inline and sidebar, including modal-authored ones). The Edit entry button moves to the far right of the file header action row, after the Sem badge and adjacent to the file actions dropdown, so the experimental affordance stays out of the everyday Viewed/Add/Comment cluster. Responsive isVeryTight behavior is unchanged (icon-only at narrow widths). * prototype: edit-session HUD strip below the file header While an edit session is active, a slim strip renders directly below the file header (inside the file card, above the content) carrying the session controls and state: Suggest, Discard, a debounced net change count (for example 3 changes), and the experimental label. The header no longer renders in-session controls; the Edit entry button still lives there when no session is active. The HUD rides Pierre's memoized custom-header slot portal, so the change count is delivered through a small external store (useSyncExternalStore) that useEditSession updates on a 250ms debounce per change event; slot height re-measures via the version-bumped updateItem that session start and end already perform. Prototype for design review; revert this commit to drop the HUD. * fix(review): pierce shadow DOM in file-nav keyboard guards Window-level keydown handlers in SectionsPanel and FileTree guarded only against e.target being an input or textarea. Events from inside the Pierre editor's shadow DOM retarget to the host element, so Home/End/arrow keys typed during an edit session fell through to file navigation and switched the visible file mid-edit. Use composedPath()[0] and isContentEditable, matching the guard AllFilesCodeView already uses. * feat(review): Make annotation selection action in edit sessions Selecting text in a Pierre edit session now shows the editor's Selection Action popover with a single Make annotation button (plain DOM, inline styles, colors via inherited theme tokens so light/dark and theme switches work through the shadow boundary). Clicking it snapshots the selection and opens the app's existing CommentPopover anchored at the button rect; the submitted comment becomes a normal line-scoped CodeAnnotation. Anchoring: the selection lives in the edited buffer, but annotations anchor to the rendered diff's new side, which is the session's pre-edit content. mapEditedRangeToPristine (edit/selectionAnchor.ts) maps the selected line range through diffLines(preEdit, edited) at click time. Unedited regions map exactly; ranges overlapping session edits anchor to the pristine lines those edits replace and are flagged approximate; pure insertions anchor to the adjacent pristine line. Pre-edit coordinates are session-invariant, so the anchor stays correct whether the session completes or is discarded. The captured selection text is stored on the annotation (selectedText, plus selectedTextFromEdits when approximate) and exported in feedback as a Highlighted text block with an honesty note for approximate anchors. New comments are re-projected into editor markers mid-session, and the editor selection collapses after submit so the popover does not reopen over the annotated lines. Entry UX note: the comment entry deliberately lives outside the editor's popover. Focusing an input inside it would blur the editor, collapse the selection, and tear the popover down mid-typing, so the popover only snapshots and hands off to the app-side CommentPopover. Tests: anchor-mapping unit tests (exact mapping through shifts, edited and inserted regions, deletions inside a selection, clamping, CRLF), export coverage for the Highlighted text block, and a DOM-gated popover builder test registered in the CI DOM step. Adapter wall unchanged and passing. * refactor(review): rename Display settings tab to Editor and move edit toggle to top * refactor(review): do not project annotations as editor markers Wavy underlines read as errors, which misrepresents comments. Annotations render in their normal slots below the code instead. --------- Co-authored-by: Michael Ramos <ramos@plannotator.ai>	2026-08-04 11:03:30 -07:00
skredik	80065c8462	perf(review): virtualize Guided Review file cards (#1158) ... * perf(review): virtualize guided review file cards * fix(review): preserve guided review card behavior	2026-07-30 20:22:48 -07:00
Kevin	193b07e22c	fix(review): bound memory for large untracked files (#1118) ... Co-authored-by: Kevin <kcosrdev@gmail.com>	2026-07-24 19:22:13 -07:00
Michael Ramos	56df64c751	Add modern GitButler review support (#1067) ... Adds current-architecture GitButler workspace, stack, and branch review support across Bun and Pi while preserving the existing Git, JJ, and P4 paths. Co-authored-by: Dan Susman <56033661+dansusman@users.noreply.github.com>	2026-07-17 07:37:50 -07:00
Michael Ramos	e8df06db7c	feat(review): Commits panel — linear history rail with per-commit diffs (#994) ... * docs(adr): spec for the commit-list review view (linear history rail) * feat(review): commit:<sha> diff mode along the shared diff-type seams A new git-only diff family for reviewing one historical commit against its first parent (git-show style), threaded through every seam a diff type crosses: - runGitDiff: git diff <sha>^ <sha>; a root commit diffs against the empty tree. Label is 'Commit <shortsha> — <subject>'. The sha is validated as bare hex (parseCommitDiffType) before it reaches any argv position, on top of --end-of-options. - getGitDiffFingerprint: anchored to the sha alone (present/gone), NOT headSha — new commits landing mid-review don't change this diff and must not raise the staleness banner. A vanished commit (rebase + gc) flips present→gone and fires it honestly. - getFileContentsForDiff: old side <sha>^ (null on root), new side <sha>. - parseWorktreeDiffType learns worktree:<path>:commit:<sha> (the sub-type contains a colon, so it needs its own split) — commit review composes with worktree sessions like every other mode. - vcs-core: the git provider owns commit:*; staging stays gated off (canStageFiles allowlist unchanged — nothing in a historical commit is stageable). - Ask AI context: a commit-mode inspect string ('git show <sha>', with an explicit 'historical commit, not the working tree' note). Also adds listCommitHistory for the upcoming /api/commits endpoint: one --first-parent page from HEAD (before=<sha> continues at its first parent, +1 fetch for an honest hasMore), with isHead / isRepoUser / isPastBase flags. isPastBase is reachability from the base — computed as the complement of 'rev-list --first-parent HEAD ^base', which is a prefix of the walk, so the client's single divider is exhaustive. An unresolvable base degrades to no divider (matches since-base's posture on such repos). * feat(review): GET /api/commits — linear history endpoint (Bun + Pi) One page of the branch's --first-parent history (?limit=&before=), served by listCommitHistory against the active diff's cwd (worktree- aware via resolveVcsCwd) and the active base (so the divider tracks the same baseline the review compares against, including the startup origin/<default> upgrade). Gated to plain local git sessions — PR / workspace / jj / p4 return 400, mirroring the client's commitsCapable gate. Both runtimes; the route-parity test covers the pair. commit:<sha> switching needs no endpoint changes: /api/diff/switch already dispatches through runVcsDiff (the git provider owns the new family), the epoch guard applies as-is, the sections sidecar correctly stays since-base-only, staging 400s via the canStageFiles allowlist, and baseRelevantDiffType keeps the behind-GitHub banner suppressed for commit diffs. * feat(ui): Commits panel view — the linear history rail Third left-panel view: 'Git status | Commits | Tree'. The Commits view is a pure commit list (short sha, subject, relative age compacted to '2h', author only when it isn't the repo user, HEAD dot, a divider where the branch meets the resolved base, 'Show more' paging). It never becomes a file list: clicking a commit switches the diff to commit:<sha> and the existing needsInitialDiffPanel flow lands the center dock on the all-files surface; re-clicking the active commit just re-focuses that panel. Persistence: reviewPanelView gains 'commits' with NO diff coupling — the view persists, the diff opens on the user's normal default until a commit is clicked, and a sha is never persisted (it may not survive a rebase). The sections⟺since-base coupling is untouched, but the classic-diff→Tree snap in Settings/ReviewSetupDialog now only fires when the current view is 'sections', so picking a default diff no longer stomps a Commits preference. The load-time self-heal ignores 'commits' by construction (it keys on panelView === 'sections'). Gates: commitsCapable = plain local git session (no PR / workspace / jj / p4, matching the server's /api/commits gate); the segment is hidden elsewhere. Staging is inert in commit diffs on both ends (STAGEABLE_DIFF_TYPES and the server allowlist never match commit:*). Worktree sessions compose — the client parses worktree:<path>:commit:<sha> and handleDiffSwitch prefixes as usual; the rail refetches on worktree/base changes but deliberately not on commit clicks, so paging state survives selection. Accepted edges (v1): no j/k selection in the rail (each move would run a full diff switch); toggling Commits→Tree keeps a commit diff active, where the tree's diff-type dropdown marks nothing — the gitRef header still names the commit. * fix(review): self-review cleanups on the commit-list feature - listCommitHistory: a repo with no commits yet (unborn HEAD) returns an empty page instead of null — the panel showed a 500-backed 'Retry' error where 'No commits' is the truth. Every other review surface already degrades gracefully on a commit-less repo; now this one does. Only a genuinely unanswerable repo (not a repo at all) stays null. - Hoist the bare-hex sha rule into one BARE_HEX_SHA_RE shared by parseCommitDiffType and the before-cursor validation (was written twice). - The 'all' diff case now uses the getEmptyTreeSha helper the commit mode extracted, instead of keeping its own inline copy. - Drop CommitsPanel's isLoadingDiff prop — declared and passed but never used. * feat(ui): commit cards, labeled groups, avatars — review round 1 Four items from the live review round: - Toggle: Commits moves to the far right (Git status | Tree | Commits) and the segment text goes 10px → 12px (padding trimmed to keep three segments inside the 256px header). - The bare '── origin/main ──' divider confused more than it explained. Replaced with two labeled groups: 'On this branch' (commits not yet reachable from the base) and 'In <base>' (shared history), each with a tooltip spelling out what the boundary means. - Rows become overview cards: subject (2-line clamp) on top; a meta row with author avatar, author name (only when it isn't the repo user), a HEAD badge, short sha, and compact age. Active card gets the primary border/tint. - Author avatars, reusing the PR machinery rather than reinventing it: parseRemoteUrl/parseRemoteHost classify the origin forge; the gh/glab invocation shape (incl. the --hostname self-hosted convention) and GitLab's relative-avatar absolutization rule are mirrored from pr-github/pr-gitlab. What could NOT be reused directly: PR avatars are keyed by platform login, which local commits don't have — so GitHub resolves via one repos/{o}/{r}/commits?per_page=100 call per session building an author-EMAIL → avatar map (unpushed commits by the same author resolve through it; verified live), and GitLab uses its per-email /avatar endpoint (capped, deduped). Everything is memoized per session and fails closed to the initials fallback — a repo with no remote, an opaque self-hosted host, or an unauthenticated CLI never delays or errors the commits endpoint. The Avatar component moves out of PRCommentsTab into its own module, now shared by the PR timeline and the commit cards. New shared module commit-avatars.ts is vendored to Pi (vendor.sh) and the enrichment runs in both runtimes. CommitListEntry gains authorEmail (resolver key) and avatarUrl (server-enriched). * ui(review): flush commit rows, prominent base boundary — review round 2 - Cards are gone: rows stack flush (no borders, no margins), hover tint only. Subject is strictly one line, ellipsized (no clamp/wrap). - Author name always shown (was: only when it differed from the repo user), with the avatar, on the compact meta line under the subject. - The base boundary is a prominent labeled rule ('— In origin/main —', foreground-weight lines) instead of the faint border under a group header; the 'On this branch' header above stays quiet. * docs(adr): evaluate local stack-parent detection — scenario matrix, no build decision Empirical stress-test of the merge-base-reachability algorithm across 9 scenarios plus this repo itself. Findings: the stacked-ness test is graph truth (never lied); parent attribution has one content-harmless failure (same-merge-base sibling labels) and one dangerous, provably graph- undetectable one (branches pointing inside B's own history win and silently hide the user's commits). Determination: only viable as a suggest-and-confirm affordance with per-branch persisted choice — never silent auto-defaulting. Decision to build deliberately left open. * fix(ui): Commits view is session-only — never the opening view Live-review catch: the panel toggle inherited the sections/tree 'last choice becomes the default' cookie write, so clicking Commits in one session made the NEXT review open on the history rail instead of the diff. Ruling: a review always opens on the persisted sections/tree default; Commits is entered via the toggle each session. - reviewPanelView narrows back to 'sections' | 'tree'; a stale 'commits' cookie is treated as unset (self-heals to the default). - The live view is now a session overlay in App state: selecting Commits flips it without touching config; selecting Git status/Tree clears it and persists as before. Single choke point in selectPanelView, so every toggle site inherits the rule. - Settings loses the Commits segment (it configures the OPENING view, which Commits can no longer be). Spec updated with the revision. * ui(review): the panel toggle is session-only — it never writes the default Second live-review ruling on persistence: the header toggle shouldn't persist ANY choice, not just Commits. Looking at another view mid-review must not silently change what the next review opens on. - selectPanelView becomes a pure session override (local state layered over the persisted value); no configStore writes from the toggle path. - handleSwitchToSections drops its defaultDiffType write — that write only existed to keep the persisted view/diff pair consistent, and the toggle no longer persists a view. Settings and the setup dialog remain the only reviewPanelView/defaultDiffType writers and keep enforcing the sections ⟺ since-base coupling; the load-time self-heal still repairs conflicted pairs those writers may leave. - Spec + settings-registry comments updated to name the new rule. * feat(ui): commit description card + collapsed all-files for commit diffs Clicking a commit now answers 'what and why' before 'which lines': - New commitInfo sidecar (Bun + Pi, same mode-conditional shape as sections): when a commit:<sha> diff is active, /api/diff and /api/diff/switch carry the commit's full metadata — subject, multiline body, author (+ avatar via the session resolver), sha, age — from a single 'git show -s' (getCommitDiffInfo in review-core, body as the trailing format field so newlines survive). - CommitDescriptionHeader heads the all-files surface: subject, author row, and the full body rendered as markdown via the same MarkdownBody the PR viewer uses. Long bodies scroll inside the card (max-h) so the diff keeps the viewport. - Commit diffs open FOLDED: AllFilesCodeView gains defaultCollapsed — items seed collapsed at build time, the seed is part of fileSetKey (CodeView seeds once per instance, so a seed change must remount), and the collapse-all toggle state initializes to match. Every other diff mode keeps opening expanded; leaving the commit diff clears the card and the folded default together (the sidecar is absent). Verified live through the compiled binary: switching to a real commit returns subject/body/avatar, switching back to since-base clears it. * ui(review): commit description scrolls with the diff — no pinned card Round feedback: the fixed header with its own inner scrollbar felt embedded; the description should read as the top of the document and scroll away with the files. - AllFilesCodeView gains leadingContent: rendered via a portal INTO CodeView's scroll container (absolutely positioned at content top, so it participates in the scrollable overflow), with its measured height fed into layout.paddingTop so the virtualized items start below it. CodeView stays the single scroll authority — no nested scrollers, no wrapper flex row. - CommitDescriptionHeader shows the full body inline (no inner OverlayScrollArea). Only genuinely huge bodies (>24 lines / >1800 chars) get a CSS max-height clamp with a fade mask and a Show more/Show less toggle — CSS clamping keeps the markdown intact, and the ResizeObserver feeds the expanded height back into paddingTop. Keyed by sha so the toggle resets per commit. * ui(review): entering the Commits view auto-opens the HEAD commit Toggling to Commits used to leave the previous mode's all-files diff on screen — a rail full of commits next to content that belonged to none of them. Now entering the view selects the HEAD commit (top of the rail) so the center immediately shows its diff + description card. Once per entry, ref-guarded: an already-active commit diff survives a toggle round-trip, a user click supersedes it, and a failed switch doesn't retry-loop. When entry races the first log fetch, the effect fires as soon as the log lands. * perf/ui(review): fast commit navigation — instant veil + skip context recompute Rail clicks felt laggy and jumpy: the old diff sat on screen for the whole switch round-trip and then snapped, and the switch itself was doing a full getVcsContext recompute (branch + worktree + recent-commit enumeration — three git walks) that a commit click can never invalidate. - Same-cwd commit:<sha> switches skip the context recompute in both runtimes (the client keeps its existing context when the field is absent — long-standing contract). Measured through the compiled binary: commit switches now ~40-60ms server-side. - The center dock shows an immediate 'Loading commit…' veil whenever a commit switch is in flight (or the Commits view was just entered and HEAD auto-select hasn't landed) — the stale previous diff never shows and the click reads as instant. Errors surface through the normal empty-state, never trapped under the veil. * fix(ui): PR-994 review round — toggle/settings separation + commit-nav fixes (App) The headline fix: the load-time settings repair guarded on the live panelView, which now carries the session toggle override — so clicking 'Git status' once mid-review (saved prefs tree + a classic diff) hit the healer and silently persisted defaultDiffType='since-base'. The toggle must never be a settings writer, directly or through a repair path. Keyed to persistedPanelView now; audited the remaining configStore.set call sites — no toggle path can reach a write. Also in this file, same review round: - Commit-navigation veil gains a real predicate: it drops on a commit-log fetch error (rail shows Retry; center was stuck under the spinner forever) AND on a genuinely empty history (zero commits — the second stuck-veil trigger the automated review missed), while still covering the log-loading and pre-auto-select frames. - handleSelectCommit composes the worktree prefix once and calls fetchDiffSwitch directly (the equality check and the switch previously used two different composition paths). - commitsCapable/showCommitsPanel hoisted above the global keyboard handler; Cmd+F is no longer intercepted in the Commits view (no search input exists there — the browser find takes over instead of a silent no-op). * fix(review): PR-994 review round — commit-log staleness, loading flags, avatar cap - useCommitLog clears its cached list when the history context changes (worktree/base switched while the view was away): the HEAD auto-select acted on the stale rows and opened the previous context's commit. Same contextKey still keeps the cache (no empty flash on re-entry). - The hook's cleanup now resets both loading flags: a generation-skipped finally never cleared them, leaving 'Show more' stuck disabled as 'Loading…' after leaving mid-page. - commit-avatars memoizes misses only for emails an attempt actually covered — the GitLab per-call cap (10) was recording every email past it as permanently unresolvable for the session. Regression test added. - GitLab host detection tightened from a bare substring to a structured match (gitlab.com / gitlab.* / *.gitlab.*) — 'mygitlabproxy.example.com' no longer classifies. - Collapse-all mirror re-derives from live item state after per-file toggles: with commit diffs seeding all-collapsed, expanding one file left the dock button on 'Expand all', and clicking it re-collapsed the file the user just opened. - The commit description card element is memoized on commitInfo identity so the measuring ResizeObserver stops churning on every context render. * fix(ui): entering the Commits view ends any open search session (self-review) The Cmd+F guard from the review round only blocked NEW searches in the Commits view; a search opened in Git status/Tree survived the toggle as hidden-but-live state — the query kept matching against the commit diff, marks kept rendering in the all-files body, Enter/F3 kept stepping matches, and the input to see or edit the query didn't exist anywhere on screen. handlePanelViewSelect (the single choke point every toggle site routes through) now clears and closes search on entry to Commits. Also re-traced the rest of the round under self-review — veil terminal states (log error/empty/loaded, switch failure, background refresh with a commit active), the hook's cleanup-before-rerun flag ordering, the avatar attempted-set on broken platforms, and both collapse-mirror paths — no further findings. * fix(ui): PR-994 round 2 — live rail freshness, non-destructive errors - The rail now keeps itself fresh: while the Commits view is visible, a quiet 10s poll head-compares page 1 and adopts it only when history actually moved. The commit DIFF's sha-anchored fingerprint stays as designed (a historical commit never goes stale, so the banner correctly stays quiet) — but the rail no longer freezes while an agent commits in the background. Adoption bumps the fetch generation so an in-flight 'Show more' from the old history can't append stale rows, and transient poll failures disturb nothing. - A page-1 fetch resets isLoadingMore: a refresh superseding an in-flight paging request skipped that request's generation-guarded finally, leaving 'Show more' stuck on 'Loading…' — rare before, a live race once the poll exists. - Errors are non-destructive when a list is on screen: a failed page or background refresh renders as an inline row with Retry under the list instead of replacing the whole rail; the full-panel error state is reserved for an empty rail. * perf/refactor(review): parallel GitLab avatar lookups; drop dead isRepoUser - The ≤10 per-call GitLab avatar lookups run in parallel instead of sequentially — they sit on /api/commits' critical path, and serial subprocess spawns added seconds to the rail's first paint on multi-author GitLab histories (PR-994 round 2 nit). - CommitListEntry.isRepoUser removed: v1 showed the author only when it wasn't the repo user; the live-review pivot to always-shown names left the field computed (one git config subprocess per page), serialized, and tested but never read, with a doc comment describing behavior the panel no longer has. Spec updated to match the revised row design. * fix(ui): commit-poll adoption clears all superseded fetch state (self-review) Adopting a new history from the background poll bumps the generation, which strands any in-flight fetch's generation-guarded finally — the same stale-flag class just fixed for isLoadingMore, but for isLoading (slow first load overtaken by the poll) — and a lingering inline error from the replaced history would otherwise sit under the fresh list. Adoption now clears isLoading, isLoadingMore, and error together. * fix(ui)/docs: PR-994 round 3 — worktree switches drop commit diffs; API docs - handleWorktreeSwitch treats commit:<sha> as non-portable: every other diff mode recomputes meaningfully against the target worktree, but a commit diff is context-bound content (worktrees share one object database — the reviewer's claimed git error doesn't exist, verified empirically), so 'preserving' it just re-rendered the OLD context's commit byte-for-byte. It now falls back to the session default (same option-availability rule resolveInitialDiffType applies). Swept every other activeDiffBase/diffType carrier: the whitespace toggle, staleness refresh, and fetch-base deliberately recompute the SAME diff (valid for commits); handleBaseSelect and the base-picker row already exclude commit mode; job diff-context labeling and the guarded diff-type dropdown are display-only. This was the single leak. - AGENTS.md (CLAUDE.md symlink): /api/commits row added to the Review Server table; /api/diff and /api/diff/switch now document the commitInfo sidecar and the commit:<sha> diffType family; the since-main section describes the three-segment session-only toggle and the never-persisted Commits view. * docs: normalize arrow glyphs in the /api/commits table row (self-review) * fix/refactor(review): PR-994 round 4 — rebase-safe paging, locale-proof ages, shared parsing - Pagination is rebase-safe: a 'Show more' cursor from a history that was rewritten mid-session (rebase/force-push) still resolves in the object store but is no longer on the branch — paging from it walked the orphaned pre-rewrite chain for the ≤10s window before the freshness poll adopts the new history. listCommitHistory now ancestor-checks the cursor (merge-base --is-ancestor) and returns an empty terminal page for orphaned AND vanished cursors alike; the poll replaces the list moments later. Regression test rewrites history between pages. - Ages are locale-proof: git localizes %cr via gettext ('vor 2 Stunden'), which the English-only compactAge regex silently couldn't shorten. CommitListEntry/CommitDiffInfo now carry committedAt (epoch ms, %ct); the rail and description card format it with the existing formatRelativeTime — compactAge and the third formatter variant are gone. - The %x1f over-split repair (fixed head/tail fields, rejoined free-text middle) was triplicated across listRecentCommits, listCommitHistory, and getCommitDiffInfo; one splitCommitFormatFields helper (head/tail counts, tail=0 covers the multiline-body shape) owns the edge case. - Avatar resets its broken-image state when src changes — latent today (every caller keys by identity), but it's a shared component and must be safe for callers that update src in place. Left alone from this round: hashString/hashFingerprintPart duplication is pre-existing, and the suggested cross-package import would drag node:path into the browser bundle — the documented reason client mirrors exist. * fix(review): PR-994 round 5 — merge-commit prompts, boundary-aware poll, auto-select guard - Agent prompts for commit:<sha> diffs instruct the exact on-screen command: git diff <sha>^ <sha> (first parent), explicitly steering away from git show — whose combined-diff presentation for a MERGE commit renders a different (often empty) changeset than the one under review. Root-commit fallback noted. One site covers Ask AI and every launched reviewer (and Pi via vendoring); prompt test pins the command. - The rail's freshness poll now adopts on boundary/base movement, not just a new head: an agent running git fetch advances origin/<base> while HEAD stays put, which re-partitions isPastBase — previously the head-only compare skipped adoption and the 'In origin/main' divider stayed stale until the view was reopened. Boundary is compared over the page-1 overlap window (a divider paged deeper than the probe can see re-syncs on the next full reload — accepted micro-edge). The reviewer's proposed trigger (the Fetch banner) is unreachable in commit mode; the external-fetch trigger is the real one. - The HEAD auto-select never fires while any diff switch is in flight — hardening only: the claimed first-click overwrite isn't reachable (isLoadingDiff was never a dependency of that effect, and auto-select settles before a human can click), but the guard makes the invariant explicit. * docs(adr): spec the pre-merge commits-view structure refactor Three behavior-preserving moves scoped for PR #994 before merge, motivated by the audit finding that every recent review-round bug lived at the App.tsx <-> useCommitLog seam: (R1) unify the commits-session state machine (poll, auto-select, veil) in one hook; (R2) lift the commit-rail block out of the 1.6k-line review-core into commit-history.ts; (R3) share the isSameCwdCommitSwitch predicate both runtimes inlined. Ownership tables name what deliberately stays put; execution runs smallest-first with full gates per commit. * refactor(review): share isSameCwdCommitSwitch across runtimes (spec R3) The ~10-line parse-and-compare predicate both /api/diff/switch handlers inlined moves to review-core beside its inputs (parseWorktreeDiffType / parseCommitDiffType — the canonical home for diff-type string logic); both call sites collapse to one line. Unit tests cover plain, worktree, cross-worktree, and non-commit-target cases. Behavior identical. * refactor(shared): lift the commit-rail block into commit-history.ts (spec R2) review-core.ts (1.6k lines) was absorbing the ~230-line Commits-panel data layer it doesn't need to own: CommitListEntry/CommitHistoryPage/ listCommitHistory and CommitDiffInfo/getCommitDiffInfo move verbatim to a new commit-history.ts, matching the package's per-concept split (jj-core, pr-stack, commit-avatars). The commit:<sha> DIFF plumbing (parseCommitDiffType, the runGitDiff/fingerprint/file-contents cases) stays in review-core with the other diff types — it participates in the dispatch; the rail does not. Wiring: review-core exports its three parsing primitives (COMMIT_FIELD_ SEP, splitCommitFormatFields, BARE_HEX_SHA_RE — listRecentCommits still uses them, so they can't move); package exports + vendor.sh gain the module (vendored siblings import relatively, same as pr-provider → pr-github); types.ts re-exports split by source; both runtimes import from the new module. History/metadata test suites move to commit-history.test.ts with the package-style per-file git harness; commit-DIFF tests stay in review-core.test.ts. Behavior identical — verified live through the compiled binary (/api/commits + commit switch + commitInfo sidecar). * refactor(ui): useCommitsView owns the whole commits-session machine (spec R1) The list cache, freshness poll, HEAD auto-select, and center-dock veil were split between useCommitLog and App.tsx — and every sync bug found across three review rounds (stuck flags, stale auto-select, adoption races) lived at exactly that seam. The auto-select effect and the veil derivation move into the hook verbatim (renamed useCommitsView, git mv), so the machine's invariants are locally checkable in one file. App now supplies only what it owns — visibility, the active commit, switch state, and onOpenCommit (its handleSelectCommit: the SAME path user clicks take, so auto- and user-selection cannot diverge by construction) — and consumes panel props plus veilActive. Net ~45 lines of App.tsx's most delicate logic deleted. One equivalence note: the hook's single "enabled" (showCommitsPanel && origin) now gates auto-select/veil where App used bare showCommitsPanel; the two only differ when origin is unset, which implies no gitContext (demo mode) and therefore showCommitsPanel === false — identical in all reachable states. Deliberately still in App (each guards a flow App owns): capability gating, handleSelectCommit, the Cmd+F / worktree-fallback / staleness-refresh / search-clear guards, and render wiring. Behavior identical; spec: adr/specs/refactor-commits-view-structure-20260703.md.	2026-07-04 10:13:11 -07:00
Michael Ramos	795f381ebe	feat(review): "All changes" git-status review view (#990) ... * feat(review): "Since main" git-status review view + correctness fixes Adds a composite `since-base` diff — merge-base(origin/main, HEAD) vs the working tree, plus untracked — as the default code-review view, rendered as a three-section "git status" panel (Committed / Changes / Untracked) with a Sections|Tree toggle, a first-run setup chooser, and a "baseline behind GitHub" fetch banner. Everything normalizes to one git patch, so the diff viewer, annotations, and feedback path are unchanged. New diff type wired through runGitDiff / fingerprint / file-content / context / staging / agent-context in packages/shared + both server runtimes (Bun + Pi mirror). Default flipped from `unstaged` to `since-base`; the old DiffTypeSetupDialog is replaced by ReviewSetupDialog (view + default-diff chooser, screenshots, Settings access). Includes a reviewed batch of correctness fixes: - P0: baseBehindRemote was permanently true (rev-parse missing --verify) - fingerprint blind to quoted/unicode untracked paths (unquote) - sections parser: record both sides of a rename; staged-delete wins over untracked (rm --cached collision) - graceful degrade when merge-base can't resolve (trunk/no-remote repos) - /api/fetch-base re-queries remote (narrow-refspec honesty) - /api/diff/switch concurrency guard (diffSwitchEpoch) + draft rekey - decouple remote-staleness probe from initialBase (Pi parity) - keyboard file nav in the sections view; banner gated to base-relative modes See adr/decisions/005-since-base-github-view-default-20260701-223706.md * fix(review): since-base review-round hardening (11 fixes, both runtimes) Addresses the multi-agent + PR-990 review findings: - Sections rename parser split ` -> ` on the raw quoted porcelain token, so a filename containing ` -> ` tore into garbage and a dirty file could render as "Committed". Now quote-aware (splitPorcelainRename + unit tests). - /api/diff/switch captured the epoch AFTER await req.json(), letting a slow-body older switch overwrite a newer confirmed one. Epoch now captured before any await; hideWhitespace committed only on win. Both runtimes. - Unresolvable base (trunk / no origin/HEAD) no longer auto-defaults to a degraded since-base that hides committed work — getGitContext only offers since-base when the base ref resolves, so the default falls through to uncommitted. Fingerprint + file-content degrade to HEAD to match the diff. - git rm --cached no longer yields two diff entries for one path (untracked files already in the tracked patch are dropped) — fixes wrong-file-open and j/k nav looping in the Sections panel; also fixes latent uncommitted/unstaged. - Settings' "Default Diff View" list now preserves the sections<->since-base coupling (can't leave an invalid sections+classic pair). - "Behind GitHub" banner only treats origin/* as fetchable; a bare local base ("main") is upgraded to its tracking ref at startup so Fetch can clear it. - hashUntracked resolves untracked paths against the repo toplevel, not cwd, so a review launched from a subdirectory isn't blind to untracked edits. - Agent review instruction now tells agents to enumerate/inspect untracked files. - Terminology: one "Committed changes" label; the live "Since <base>" label is dynamic (matches the header); "Since main" kept only as product copy. - Docs: CLAUDE.md endpoints/fields + since-base view section; ADR recap. Verified: typecheck (all projects), bun test 1793 pass, and empirical repro of the rm --cached dedup, trunk->uncommitted fallback, and rename parser. * fix(review): restore "(PR view)" on the Committed-changes label (unify toward it, not away) * fix(review): close since-base coverage gaps from PR-990 review round 2 - First-run setup no longer forces since-base on repos where it isn't available (base ref can't resolve). getGitContext omits since-base there; the first-run block now checks the same availability before resetting the default or showing the chooser, so committed work isn't silently hidden on trunk/no-origin repos. - reviewBase now includes 'since-base', so changing the base while in the git-status view passes the selected base to /api/file-content — expandable context is fetched from the right merge-base (was falling back to default). - Settings now mirror ReviewSetupDialog's coupling exactly: Sections ⇒ force since-base; Tree ⇒ leave the diff (Tree + since-base is valid and now saveable); classic diff ⇒ Tree; since-base diff ⇒ leave the view. Removes both coercions that previously discarded a supported preference. * fix(review): PR-990 review round 3 — fingerprint/dedup/base-canonicalization - Fingerprint now uses `git status --porcelain -uall`, so editing a file inside a brand-new untracked directory changes the fingerprint and the "Diff out of date" banner fires (was collapsed to `?? dir/` and hashed as unreadable). - extractTrackedPatchPaths pairs `---`/`+++` and excludes only the file's KEYED path (new side, or old side for a pure deletion) — no longer drops a recreated rename-source file (`git mv a b && touch a`). Verified rm --cached still dedups to one entry and the recreated file still shows. - resolveReviewBase canonicalizes a bare local default name ("main") to its tracking ref ("origin/main") on every call, so a client that loaded before the startup upgrade resolved can't revert the server to the stale local base on the next refresh/switch. Both runtimes (new Pi resolveReviewBase helper). - Removed the dead activeDiffLabel prop chain (FileTree -> DiffTypePicker). - ADR recap: documented the staleness-banner scope limitation (default base only). Verified: typecheck (all projects), bun test 23/23 review-core+fingerprint pass, empirical repro of the untracked-dir fingerprint, rm --cached dedup, and rename-recreate cases. * fix(review): PR-990 review round 4 — dedup content, staging gate, banner timing - Dedup rewrite: instead of dropping the untracked side of a same-path collision (which hid content), drop the tracked DELETION block and keep the untracked working-tree content. `git rm --cached f` + edit now shows the new content, not a phantom deletion — still one entry per path (no dock/nav collision). New stripHeaderPath also strips git's trailing-tab metadata, so space-named files dedup correctly. Verified: rm --cached+modify shows content (1 entry), space-named (1 entry), rename+recreate still shows both. - All-files (and the `a` shortcut on the focused file) now gate staging per-file: committed files in since-base mode are not stageable, matching SectionsPanel / FileTreeNode. Shared isPathStageable helper threaded via ReviewStateContext → AllFilesCodeView. Stops the confusing `git add` no-op that still flipped local staged/viewed state. - /api/diff/switch now awaits recomputeBaseBehindRemote before building the response, so the "Baseline behind GitHub" banner reflects the new base immediately (no ~5s lag switching in, no stale banner switching away). Both runtimes. - ReviewSetupDialog re-applies the recommended default only on first-run dismiss, not when reopened from the header menu (was snapping a mid-session diff back). - SectionsPanel "N added" header now counts sidecar-staged files too, so it matches the staged dots on rows. Verified: typecheck (all projects), bun test 1830 pass, empirical dedup repro, both bundles build. * refactor(review): reuse parsePatchPathToken in removeTrackedDeletions (self-review) Drop the duplicated stripHeaderPath helper — the shared diff-paths parsePatchPathToken already strips a/|b/ prefix + C-quoting + git trailing-tab, and verifies the prefix instead of blindly slicing two chars. Documents the binary-deletion edge (no --- line, so a binary rm --cached is not deduped). * fix(review): PR-990 review round 5 — mixed-base + staging/sort/flicker nits - Atomic base upgrade: the startup origin/* canonicalization swapped currentBase without rebuilding the patch, so /api/diff could advertise origin/main while the served hunks came from local main (mixed-base review on origin/HEAD-absent repos). Now rebuilds the diff for the new base and commits base+patch+ref+ fingerprint together (only if no user switch happened); the fingerprint change makes the client's freshness poll pick it up. Both runtimes. - isPathStageable: gate staging OFF when since-base is active but the sidecar hasn't loaded (was falling through to true, allowing a git-add no-op on a committed file). - SectionsPanel: session-staged files now float to the top of Changes — the sort key was `false ?? stagedFiles.has(...)` which short-circuits; now ORs them. - /api/diff/fresh: early returns now carry baseBehindRemote, so a snapshot change mid-probe no longer clears the "behind GitHub" banner for one poll. Both runtimes. - Removed the now-dead activeLabelFallback prop from DiffTypePicker (FileTree stopped forwarding it in round 3). Skipped (agreed): the fetch-base input-validation nit (no realistic attacker) and the diff-switch TOCTOU (concurrent switches aren't UI-reachable). Verified: typecheck (all projects), bun test 1830 pass, both bundles build. * refactor(review): drop redundant staged-OR in SectionsRow (self-review) item.staged (the grouping key) already ORs in stagedFiles as of the round-5 sort fix, so the row-level `|| stagedFiles.has(...)` is dead weight. * fix(review): surface the startup base upgrade to already-loaded clients Review round 6 fixes: - The startup main -> origin/main upgrade re-baselined the freshness fingerprint, so a client that fetched /api/diff before the rebuild kept the old patch and every /api/diff/fresh probe reported fresh (the probe compares server state to itself, never to what the client renders). Now the fingerprint is only re-baselined when no client has loaded the pre-upgrade snapshot; otherwise the stale baseline trips the normal "Diff out of date - Refresh" banner. Bun + Pi. - preserveFile refreshes (staleness Refresh, post-Fetch) now adopt the server's returned base — exactly the paths where the server may have canonicalized main -> origin/main; keeping the old name sent /api/file-content and Ask AI context against the wrong base. - ReviewSetupDialog: clamp the fixed 800px height to the viewport so the dialog fits on small laptop screens. - Docs: /api/diff/fresh response also carries baseBehindRemote/agentCwd. - Documented the committed-deletion + untracked-recreation dedupe edge as accepted (code comment + ADR) — fixing it needs two same-path diff entries, which the path-keyed UI cannot represent. * fix(review): stop the Git-status default from silently reverting to tree Users with reviewPanelView=sections could keep opening in the tree view on a stale diff type despite their cookie saying Git status. Three causes: - The header Sections toggle persisted the view but not defaultDiffType, creating a conflicted pair (sections + non-since-base default) that every UI writer is supposed to prevent. It now couples the diff default like the setup dialog and Settings do. - configStore's debounced POST /api/config could be lost when a session closed within 300ms of a change, leaving cookie and config.json split. Pending writes now flush on pagehide with a keepalive fetch. - configStore.init() applies config.json over the cookie without the UI coupling, so a stale server value re-corrupted the pair on every load. The app now self-heals at load: if the view says sections but the diff default isn't since-base, it repairs the default (cookie + config.json) and switches the live session to since-base. * fix(ui): keep the stage (+) button border visible on the active file row The button's --border border has no contrast against the active row's 30% primary tint, so it vanished on the selected row until hovered. Tint the border with the row's primary color on active rows (both sections and tree views); the button's own hover border still applies. * ui(review): spell out the panel view toggle — 'Git status | Tree' text instead of icons * fix(review): PR-990 review round 7 — export label, diff snapshot race, unicode paths - exportFeedback describeDiff(): add the missing since-base case — every feedback export in the new default mode read "**Diff:** since-base". - /api/diff GET: snapshot patch/base/ref/error BEFORE the sections-sidecar await and pass the pinned base into buildSectionsSidecar. The startup base upgrade landing mid-await could pair a rebuilt patch with sections grouped against the old base, with initialDiffServed still false so no refresh banner ever came. Bun + Pi. - SectionsPanel: a session-staged untracked file now moves to the Changes section immediately (anticipating the server's next sidecar) instead of sitting in Untracked with a staged dot until refresh. - unquoteGitPath: real C-style unquoting with octal (UTF-8 byte) escape decoding. JSON.parse rejects octal escapes, so non-ASCII names kept their literal \303\251 form — an untracked "café.txt" was silently ABSENT from the review (git diff --no-index could not access the quoted name) and the deletion dedupe Set lookup could never match. getUntrackedFileDiffs now unquotes ls-files output. Unit tests: octal decoding + end-to-end unicode untracked file in a real repo. - review-core.test: worktree subtype round-trip now covers since-base and all (was 6 of 8). Parked (deliberate): SectionsPanel/FileTree keyboard-nav dedup refactor. * fix(shared): unquoteGitPath keeps literal unicode intact (self-review) The byte-collector treated literal non-ASCII code units as single bytes, which would mojibake headers synthesized by our own quoteGitPath (JSON.stringify leaves unicode unescaped inside quotes — workspace-mode prefixed headers round-trip through the same parser). Literal chars now append as string code units (surrogate-safe); only octal escapes go through the UTF-8 byte decoder. * fix(review): PR-990 review round 8 — pre-staged toggles, explicit base, AI context race - useGitAdd: session Set replaced with a tri-state override map folded over the sections sidecar; stagedFiles is now the EFFECTIVE staged set (sidecar + session stages - session unstages). Fixes pre-staged files: the first `a` press actually unstages (was a git-add no-op), the sidebar dot clears after a real unstage (was stuck via sidecar OR), and the All-files header agrees with the sidebar on load. Overrides reset whenever a fresh sidecar arrives (switch, preserveFile refresh, PR response) so stale session intent can't fight new porcelain truth. SectionsPanel drops its own sidecar OR; stagedCount = effective size. - Explicit base picks are honored verbatim: the picker sends explicitBase, and the server permanently disables local-name -> origin/* canonicalization once set (the local/remote groups are distinct choices). The behind-GitHub banner also exempts an explicitly-picked local name — Fetch advances origin/*, so the banner would be un-clearable nagging. Bun + Pi. - buildCurrentAiReviewContext(patch, base): GET /api/diff builds Ask AI context from the same served snapshot as the patch — the startup base upgrade could hand Ask AI a different changeset than the screen. Bun + Pi. - recomputeBaseBehindRemote: capture remoteDefaultInfo once — a concurrent refresh nulling it mid-await threw. Bun + Pi. - Revert stray "Status Update / Updated!" edit to adr/0001 (test debris swept into the round-2 commit). - splitPorcelainRename comment corrected (porcelain v1 does NOT quote plain spaces; a name containing " -> " is ambiguous without -z) + ADR notes for the index-only-changes semantics and the rename edge. * fix(review): FileTreeNode uses the effective staged set — round 9 Round 8 made stagedFiles the effective set (sidecar + session overrides) and removed SectionsPanel's sidecar OR, but missed the same OR in FileTreeNode's since-base row (sectionStaged). In the Tree fallback a pre-staged file unstaged this session kept its dot and the next toggle re-staged it. Grep-swept: this was the last surviving sidecar-staged OR. * refactor(review): make the staged-display invariant unrepresentable The round-8/9 bug class (sidecar staged flag ORed over the effective set) existed because surfaces had a second staging source to reach for. Remove it: stagedFiles is now a REQUIRED prop on SectionsPanel/FileTree/ FileTreeNode and the optional-prop fallback branches reading sectionEntry.staged for display are deleted — a future surface cannot reintroduce the OR because the pattern no longer exists to copy. The sidecar type's staged field and AGENTS.md now document the invariant at the point of temptation. Grep for display reads of .staged now hits only useGitAdd (owner) and the sidecar builder (producer). * refactor(review): self-review cleanups on the staged-invariant hardening - orderFilesBySections: document why its snapshot .staged read is safe (only called at sidecar-fresh moments where snapshot = effective) and that it must not be reused mid-session — the one remaining display-side snapshot read the invariant sweep surfaced. - FileTreeNode: drop the now-pure sectionStaged alias; use isStaged. * fix(review): PR-990 review round 10 — header staging gate, fingerprint cap, single-writer coupling - Single-file diff header now uses the per-path staging gate (canStagePath), closing the last ungated staging trigger: committed-only files in since-base offered a no-op Git Add that flipped local staged/viewed state. Full trigger inventory swept: App `a` shortcut, all-files `a` + header, SectionsPanel rows, FileTreeNode rows, single-file header — all six now per-path gated or group-gated; no context-menu staging exists. - Fingerprint circuit-breaker: the freshness poll's `git status --porcelain -uall` degrades permanently (per cwd, per process) to collapsed -unormal once its output exceeds 2MB — a forgotten node_modules/ no longer burns CPU every 5s for the whole session. Costs untracked-dir edit sensitivity only on such repos; one possibly-spurious staleness banner at the switch. - The sections ⟺ since-base coupling now has a single writer: setReviewPanelView/setReviewDefaultDiffType in @plannotator/ui/config. All five call sites (setup dialog x2, Settings x2, header toggle, first-run reset, self-heal) converted; grep for direct writes of either setting now hits only reviewView.ts. - /api/diff/switch responses pass snapshot args to the AI context builder (both branches, Bun + Pi) — correct today, now robust against future awaits between the epoch check and the response. - Docs: explicitBase in the /api/diff/switch body. Parked per discussion: SectionsPanel/FileTree nav+search+footer dedup (extract when the commit-list view adds a third panel), querySelector row measurement, fetch-base stderr passthrough (standing decision), Pi hasAgentLocalAccess (pre-existing follow-up list). * fix(review): PR-990 review round 11 — subdirectory launches, escape decode, settings note - Repo-root-relative patch paths now resolve against the git toplevel everywhere they meet a filesystem path or pathspec, via a shared resolveRepoToplevel helper: file-content working-tree reads (hunk expansion returned null from a subdirectory launch) and gitAddFile/ gitResetFile (stage/unstage failed with pathspec errors). Both bugs pre-existed for uncommitted/unstaged; since-base made them the default experience. The two existing inline toplevel resolutions (untracked diffs, fingerprint) now use the same helper. Shared code — Pi inherits via vendoring. Real-repo subdirectory tests for both. - unquoteGitPath decodes \uXXXX (JSON.stringify emits it for control chars without a short escape; our synthesized workspace headers round-trip through this decoder). Malformed \u stays literal. Tests. - Pi explicitBase guard matches Bun byte-for-byte on empty-string base. - Settings Git tab notes when the CURRENT repo can't serve the Git-status view (base ref unresolvable) instead of letting the preference look silently broken — it's a global preference, so the options stay. Same-class items left parked (pre-existing, untouched by this PR): open-in root resolution and code-nav file reads from subdirectory launches — on the follow-up list with the Pi divergences. * fix(review): PR-990 review round 12 — per-client freshness, keyboard-operable row controls - Freshness is now judged PER CLIENT: every patch-carrying response (/api/diff, /api/diff/switch, pr-switch, pr-diff-scope) includes snapshotId (the server's draftKey), and the client echoes it on /api/diff/fresh probes. A mismatch reports stale for THAT client regardless of the VCS fingerprint. This fixes the round-12 finding — reloads/second tabs after the startup base upgrade got a permanently bogus staleness banner from the shared pre-upgrade baseline — and deletes the round-6 conditional re-baseline hack entirely (the fingerprint recaptures unconditionally again; the old client's banner now comes from its snapshot mismatch, not a deliberately stale baseline). Also gives unfingerprintable modes (P4, PR layer) snapshot- level staleness for free. Bun + Pi + client hook. - StageControl and ViewedControl (which had the identical gap) are keyboard-operable: tabIndex + Enter/Space activation + focus outline. They're spans inside the row <button> (nested real buttons are invalid HTML), so they need their own focus stop; the a/v shortcuts remain the power path. - Docs: snapshotId on /api/diff, ?snapshot= on /api/diff/fresh. * fix(review): PR-990 review round 13 — re-key snapshots on scope switch, PR-tab refresh - The PR scope switch now re-keys draftKey (= snapshotId + draft storage key) at BOTH commit points, unconditionally — matching every other snapshot commit site. The full-stack branch previously kept the layer patch's key: stale layer tabs never got the banner after a cross-tab scope switch (the exact case snapshotId exists for), and full-stack drafts collided with layer drafts (pre-existing). The layer branch's !layerPatchIncomplete conditional is gone — it only stayed consistent because full-stack never re-keyed. Invariant now: every currentPatch commit is followed by a re-key. Bun + Pi. - Refresh works for any stale PR tab: re-selects the CURRENT scope instead of no-opping for layer (only full-stack could go stale in the fingerprint-only world; snapshot mismatch changed that). Accepted residual (documented in code): after a cross-tab PR switch, refresh updates the patch but not prMetadata — the scope endpoint doesn't carry it, and the full-rehydrate refactor isn't worth the two-tab edge. * fix(review): stale incomplete-layer Refresh uses the non-blocking upgrade path (self-review) Round 13 made Refresh re-select the current scope for stale PR tabs; for an INCOMPLETE layer patch that POST triggers the server's local recompute, which can park for minutes behind checkout warmup — and handlePRDiffScopeSelect renders the full-screen switch overlay the whole time. Route that case through handleLoadFullDiff (same POST, progress notice instead of modal), which exists for exactly this slow path. * fix(review): round 14 — composite snapshot id, fully-pinned /api/diff, "All changes" label - snapshotId is now content hash + diff type (+ PR scope), built by a single currentSnapshotId() helper used at every response site and the freshness compare. A cross-tab MODE switch with a byte-identical patch (layer vs full-stack on a single-PR stack) now flags old tabs; the base is deliberately excluded so a same-commit main -> origin/main canonicalization stays banner-silent (round-12 noise-avoidance kept). draftKey stays a pure content hash — drafts survive content-identical round-trips. Bun + Pi. - GET /api/diff pins ALL served fields (diffType, hideWhitespace, prDiffScope join patch/base/ref/error/snapshotId) and the sidecar + AI context builders take the pinned type instead of reading globals — a concurrent tab switch during the sidecar await can no longer produce a since-base patch labeled with another mode. Bun + Pi. - First-user feedback: the since-base label is now plain English — "All changes since origin/main" (dynamic, follows the picked base); dialog/Settings short form "All changes"; feedback exports match. uncommitted reverts to "Uncommitted" where it had borrowed "All changes", so the two stay distinguishable side by side. * docs(review): finish the Since-main -> All-changes terminology sweep in comments (self-review) * fix(review): PR-990 review round 15 — base-revert race, freshness reset, unstage regroup - resolveReviewBase gains a second, probe-independent rule: a non-explicit echo of the bare local name of the CURRENT origin/* base stays on the tracking ref. The existing rule keys off remoteDefaultInfo, which comes from a second network probe that can lag the startup upgrade by seconds; in that window a diff-type/whitespace switch echoing "main" committed the session back onto the stale local branch and set baseEverSwitched, permanently blocking the upgrade. Bun + Pi. - useDiffFreshness resets stale/dismissed state on snapshotId too — since round 14 a new snapshot can reuse identical patch text with a different id, and the old banner state wrongly carried over until the next poll. - SectionsPanel: unstaging a PRE-staged add moves it back to Untracked (mirror of the round-7 stage regroup). Detection deliberately uses the sidecar's snapshot flag to recognize "was pre-staged"; staged modifications stay in Changes, staged renames remain a refresh-heals edge. * fix(review): PR-990 review round 16 — rename staged count, guarded fetch-base replay - "N added" no longer double-counts staged renames: the sidecar truthfully marks BOTH porcelain sides staged, but an above-threshold rename renders as ONE file — the hidden old path inflated the count and left a phantom effective-staged entry that unstaging the visible row couldn't clear. The client now filters sidecar-staged paths to rendered files, which is correct in both patch shapes (below-threshold renames render delete+add as two rows and both sides pass the filter). Client-only; the sidecar stays faithful to porcelain. - The fetch-base completion only replays the diff refresh if the user's diff type/base selection is unchanged since the click — a slow fetch no longer yanks the review back to the view captured at click time. Declined with reasons (in review thread): first-run persist-before-confirm (approved forced default, second flagging), explicit-base flag ordering (early-set preserves user intent; commit-after-win would leave picker and server disagreeing), base-picker revert target (near-unreachable compound race, deferred). * fix(review): PR-990 review round 17 — find origin/main on feature-only clones getDefaultBranch's chain (origin/HEAD -> local main -> blind "master") skipped the fetched remote-tracking ref entirely. On checkouts with no origin/HEAD symref and no local main/master — CI checkouts, `clone --branch feature`, extra worktrees — it guessed "master", the base didn't resolve, getGitContext suppressed since-base, and the flagship "All changes" view silently disabled itself for the whole session even though origin/main was fetched and diffable. The startup upgrade can't rescue it either (its guard reads the bogus "master" as a deliberate non-default base). Chain is now: origin/HEAD (verified) -> origin/main -> local main -> origin/master -> "master" — remote-tracking refs preferred, matching the function's stated prefer-upstream intent. Shared core (Pi inherits); real-repo test reproducing the exact clone shape.	2026-07-04 09:53:49 -07:00
Michael Ramos	e1efea8bd4	feat(review): file comments in the diff + unified click-to-highlight comment UX (#973) ... * feat(review): file comments in diff + unified click-to-highlight comment UX Render file-scoped comments inline in the code review UI and overhaul the comment-card UX for consistency. File comments - Single-file view: a full-text banner below the file path. - All-files view: rendered in the file header (expanded files only) — Pierre's virtualized custom header suppresses the body-prefix slot, and its measured item heights make a taller header safe. Guided-review external annotations can now drop the line-1 anchor hack. Click-to-highlight - Clicking a comment (inline card or sidebar) replays its stored line range as the controlled selection highlight; clicking it again clears it. - Scroll/navigate is sidebar- and findings-list-only (token-based signal) so clicking a comment in the diff never moves the viewport. Unified comment cards - Shared CommentMeta identity row (badges + author + relative time) across the inline, sidebar, and file-banner cards (were three hand-rolled headers). - Shared FileNameChip (basename, full path on hover) replaces the literal "file" badge everywhere. - Force the app sans font on cards (inline was inheriting the diff's monospace), consistent selected ring, spacing, and absolute hover actions so timestamps align across surfaces. Shared helpers: annotationScope (PR-scope / file-scope / line-range projection) and fileName (basename). Plumbs createdAt through DiffAnnotationMetadata so the inline cards can show timestamps. * feat(review): unify comment action row (edit · copy · delete) Shared CommentActions component used by the inline diff card, the file-comment banner, and the sidebar — bottom-aligned, hover-revealed, order left→right edit · copy · delete (delete/close furthest right). - Inline + banner: actions moved from the top (where they overlapped the timestamp) to the bottom, and gained the copy button. - Sidebar: now uses the same component (copy + delete) — same icons, order, and styling. - Read-only (externally-sourced) file comments show copy only. - Extract commentCopyText() so every card's copy produces identical, self-describing text (location prefix + body + reasoning); drops the format that was hand-built in the sidebar and the agent-job panel. - Rename PRCommentsTab's local CommentActions -> PRCommentLinkActions to avoid the name clash with the shared component. - Remove the now-dead .review-comment-action(s) CSS and CommentMeta's trailing slot. * fix(review): address PR review findings - all-files: let an active compose own the line highlight (pendingSelection guard) so clicking/deselecting a comment mid-compose no longer clobbers the toolbar's range — mirrors single-file's `pendingSelection ?? annotationRange`. - clear scrollTargetAnnotation on inline select so a remount (Refresh / base switch) doesn't re-scroll back to a stale sidebar/findings navigate target. - inline diff cards: hide edit/delete for external (source-set) findings (matches the file-comment card) and copy with the file:line location prefix via a precomputed metadata.copyText (commentCopyText), unifying the copy text. - add decorations + createdAt to the file-comment refresh signature so an external PATCH changing only those repaints the all-files header. - wrap finding reasoning text (overflow-wrap/word-break) so long file:line refs no longer bleed past the card edge. * refactor(review): dedupe line-annotation projection + close signature gaps Self-review follow-ups to the PR-feedback fixes: - Extract lineAnnotationMetadata() — the all-files and single-file diff surfaces built the identical 14-field DiffAnnotationMetadata; now one source of truth. - Add reviewProfileLabel + source + createdAt to the LINE-scope refresh signature: the unified CommentMeta now renders those on inline cards too, so an external PATCH changing only them must repaint the item (same gap that was just fixed for the file-comment tuple). - Wrap the agent-job panel's finding text + reasoning (overflow-wrap) so long file:line refs don't bleed past the panel edge, matching the inline card fix. * fix(review): zero inter-file gap + stop file-path descender clipping - all-files: set CodeView layout gap to 0 (Pierre default was 8) so files sit flush; sticky headers already mark file boundaries. Keep default edge padding. - FileHeader: path text leading-none -> leading-normal so the overflow-hidden ellipsis box has room for descenders (g/y/p were clipped by the box bottom). * fix(review): address 2nd-pass review — header re-measure, delete, highlight - all-files file comments: re-measure the CodeView item when a comment expands/collapses/edits (FileCommentCard -> onHeightChange -> refreshItem) so Pierre repositions following items instead of overlapping them. Fixes the dynamic header-height bug; the remaining static sticky-offset drift is bounded by the new banner cap and stays the accepted trade-off. - cap the expanded comment body (max-h + overflow) so a long guided-review note doesn't fill the viewport / inflate the sticky header. - delete is now available on every surface (inline, banner) including external source-set findings; edit stays gated on !source. - restore the line highlight when a compose ends: the all-files pendingSelection effect now re-derives the selected comment's range instead of clearing (mirrors single-file's pendingSelection ?? annotationRange). - add reasoning to the file-comment refresh signature (copyText includes it). - guard handleNavigateToAnnotation with annotationMatchesPrScope so a stale sidebar/finding row can't navigate to an out-of-scope annotation. * refactor(review): share annotation→highlight derivation + smoother re-measure Self-review follow-ups: - Extract lineSelectionForAnnotation() — the compose-end restore and the selection-replay effect built the same annotation→CodeViewLineSelection by hand; share it so they can't diverge. - Re-measure file-comment height via useLayoutEffect (before paint) instead of useEffect, so an expand/collapse lands without a one-frame overlap. * fix(review): ignore navigate to missing annotation + re-seed on scope switch - handleNavigateToAnnotation: return early when the annotation id is gone (deleted) as well as out-of-scope, so a stale row can't leave an orphan selection (ring with nothing to scroll to). Dismissed agent-panel rows are already non-clickable; this is the belt-and-suspenders for any other path. - fileSetKey now includes prUrl/prDiffScope so a pure layer<->full-stack scope switch (same file set) remounts and re-seeds annotations through the current scope filter — the incremental sync bails on an unchanged annotations ref and can't otherwise detect the filter change. * fix(review): allow editing external/source findings inline again Drop the editable = !source gate on inline and file-comment cards. main always showed edit for external findings (it routes through updateExternalAnnotation), so gating it was a regression. Edit, delete, and copy are now all available on every comment surface regardless of source. * refactor(review): drop redundant null-check after navigate guard annotation is guaranteed non-null past the missing/out-of-scope early return.	2026-06-26 12:19:49 -07:00
Michael Ramos	2a6fe5c457	Open files in external apps + code-review UX pass (#942) ... Adds a server-side "open the current file in an external app" control to the code-review and annotate surfaces (split-button with host-detected apps; last-used becomes the default; cross-platform launch mirrored across the Bun and Pi runtimes), plus a code-review UX pass: file-header change letters and line counts, the diff-settings cog grouped with Split/Unified, an all-files collapse/expand-all toggle, and the semantic diff moved to a resizable sidebar accordion. Also fixes Cmd+click code navigation (worker token transformer). Hardened over three adversarial review rounds: shared, tested path-containment for open-in (Bun + Pi), annotate scoping aligned to /api/doc reference roots, strict PR-checkout rooting (never the launch repo), deduped app-catalog and semantic-diff fetches, macOS bundle-only availability, Windows launch fixes (reveal + terminal off cmd's parser), and PR-checkout tracking across switch and pool warmup.	2026-06-19 08:56:06 -07:00
Michael Ramos	6ec1a66c9b	feat(review): large-PR pipeline, instant-open checkout, scroll perf, and worker-pool highlighting (#893) ... * feat(review): large GitHub PR fallback + non-blocking PR checkout Two PR-mode improvements: 1. Large GitHub PRs no longer fail to load. When `gh pr diff` is refused (HTTP 406 for oversized diffs), fetchGhPR pages through the pulls files API and stitches the per-file patches into a unified diff — mirroring the existing GitLab raw_diffs fallback. Path quoting matches git's exact rules (bare spaces unquoted) so downstream parsers round-trip; truncation at the API's 3000-file cap is surfaced, never silent. 2. The --local worktree/clone no longer blocks startup. The review server opens as soon as the platform diff arrives; the checkout warms in the background as a seeded not-ready pool entry. Consumers that need real files (agent jobs, full-stack diff, code-nav, semantic diff, AI sessions) await pool.ensure(), with creations serialized so concurrent fetches can't clobber the shared FETCH_HEAD. Cross-repo clone steps converted from spawnSync to async spawns; warmup children are killed on exit (plus `git worktree prune`) so aborted sessions can't leak stale registrations; failed checkouts degrade honestly (no agent runs in the wrong directory claiming local access) with a 30s retry cooldown. * fix(review): survive long PR checkout warmups + classify reconstructed renames Stress-testing against oven-sh/bun#30412 (2,188 files) surfaced three bugs: - Bun.serve's default 10s idleTimeout killed /api/semantic-diff while it parked on the background checkout warmup (a clone that can take minutes). Disable the idle timeout on all servers — AI SSE streams can also stall >10s between bytes while a permission prompt waits. - The file-badge hook memoized that failed fetch in a module-level cache keyed by patch, pinning every badge to empty until a hard refresh. Never cache failures; retry with backoff (5s/15s/30s). - reconstructGhPatch/reconstructPatch omitted the `similarity index` line, which Pierre's parser keys rename classification off — pure renames rendered as blank plain changes with no old path. Emit 100% for patch-less renames/copies (exactly accurate) and a synthetic 99% for patched ones (consumers only branch on 100% vs not). * feat(review): local full-diff upgrade for PRs whose API diff is truncated On oversized PRs the platform APIs withhold per-file patch content entirely (bun#30412: 1,066 of 2,188 files came back with status added/modified, zeroed counts, and no patch). Those files rendered as empty stubs with no diff. - fetchGhPR/fetchGlMR flag the result `patchIncomplete` when patch-less non-rename entries exist or the 3000-file cap truncates the listing. - New runPRLayerLocalDiff (pr-stack.ts) recomputes the exact layer diff in the local checkout: platform merge-base + head SHA two-dot diff (three-dot vs baseSha fallback), fetch-by-SHA for objects missing from shallow clones, -l0 so rename detection doesn't silently degrade on huge PRs. - The review UI shows a "Partial diff · Load full diff" notice in layer scope; clicking re-requests the layer scope and the server swaps in the recomputed full diff (waiting out the background clone if needed). - PR scope/switch state writes are epoch-guarded: a request parked on the checkout warmup can no longer overwrite a newer scope select or pr-switch. - draftKey follows the upgraded patch so annotation drafts survive pr-switch round-trips; recompute failures surface in the response error field. - Pi server mirrors all of it, including an agentCwd fallback so the upgrade works for PRs switched-to under a cross-repo clone pool. * fix(review): use GitLab's too_large/collapsed flags for withheld-diff detection External review caught a false negative: a too-large ADDED file comes back new_file:true with an empty diff — indistinguishable from a legitimately empty new file under the old heuristic, so the partial-diff upgrade was never offered for exactly the files that matter most on big MRs. The REST /diffs endpoint marks withheld content explicitly per entry (verified against gitlab.com): too_large/collapsed are now authoritative in both directions — withheld adds/deletes are flagged, binaries and empty files are never misflagged. Older GitLab without the fields keeps the empty-diff-on-modification heuristic. * feat(prompts): unify review-denied suffix — triage first, no coding off raw feedback The per-runtime defaults map (#627) gave OpenCode and Pi a different review-denied suffix than every other runtime; updating one meant the others silently kept "you must address all of them" — an instruction to start coding immediately. Claude Code, Amp, Droid, Codex, Copilot, Gemini, and Kiro were all still on it. One default for every runtime now: triage the feedback, verify it against the code, discuss before changing anything. Per-runtime customization remains available via config (prompts.review.runtimes.<rt>.denied), which resolves above the built-in default as before. * fix(prompts): generalize review-denied suffix — 'from review', not 'external AI reviewers' Review feedback isn't always from AI reviewers or agent jobs; often it's the human reviewer's own annotations. Neutral wording covers both. * fix(review): non-blocking 'Load full diff' + flag-handling hardenings Self-review findings: - The partial-diff upgrade reused the scope-switch handler, so clicking "Load full diff" raised the full-screen PRSwitchOverlay — blocking the entire UI, potentially for minutes behind a cold clone, with no text and no cancel. The upgrade now has its own loading state: the notice shows a spinner ("Loading full diff…") and the reviewer keeps working with the partial diff while the request parks. Server-side epoch guards already handle scope/PR changes made during the wait. - GitLab too_large/collapsed: treat explicit null like absent (flags inconclusive → legacy heuristic decides) instead of silently exonerating. - Rename-limit lift uses -l100000 instead of -l0 ("0 = unlimited" only holds on git >= 2.29; on older git it could disable detection outright). * fix(review): stop scroll-driven sem stampede when semantic diff is failing The badge retry change (a2d19a4e) cleared the client-side sem cache on failure so transient errors could recover. But file-header badges mount and unmount on every scroll in the virtualized all-files view, and each mount re-requests /api/semantic-diff — and the server only cached SUCCESSFUL runs. With sem erroring, scrolling spawned a continuous stream of sem processes, pegging the CPU and making scrolling severely choppy. Bound retry rate by time, not by mount events: - client: keep the failed result memoized and expire it after a 60s cooldown instead of clearing immediately - server (Bun + Pi): memoize failed sem runs for 30s in SemanticDiffResponseCache — request rate can no longer drive execution rate * fix(review): eliminate all-files scroll jank (pre-existing on main, from #885) The CodeView migration introduced severe scroll chop; scrolling UP could freeze the viewport entirely ("scrolling but nothing changes"). Three compounding causes, diagnosed against Pierre 1.2.8 source: 1. Lazy full-content augmentation landed updateItem() mid-scroll-gesture: the full-content parse counts collapsed-context regions the raw-patch parse doesn't, so the item GROWS — re-render + re-tokenize hitches both directions, and when the grown item sat above CodeView's scroll anchor, its corrective scrollTo() killed wheel momentum (the up-scroll freeze). Fetches still start as items enter the window; the item mutation now waits for 150ms of scroll quiet (staleness re-checked at apply time). 2. reportVisibleFile read container.scrollTop/clientHeight/scrollHeight on EVERY scroll event — a forced synchronous layout right after each frame's DOM writes. Replaced with CodeView's cached accessors and coalesced the handler to once per animation frame. 3. Missing containment CSS: Pierre's own production wrapper uses contain:strict + will-change:scroll-position so forced layouts stay scoped to the scroller instead of the whole document. Adopted. Also: __devOnlyValidateItemHeights now requires explicit opt-in (VITE_PIERRE_VALIDATE_HEIGHTS=1) — it runs getBoundingClientRect() per rendered item per frame and made dev-server scrolling choppy by itself. * feat(review): change-type status in headers + tree, diffshub CSS parity Adopts two diffshub practices identified in the architecture comparison: - DiffFile now carries a derived status (added/deleted/renamed/modified) from the chunk's git metadata lines. FileHeader shows a status icon and renders renames as "old/path → new/path" (dimmed old, arrow — diffshub's treatment, including its rename blue); the file tree shows A/D/R markers. 'modified' is deliberately undecorated so the others pop. Works in both the all-files surface and the single-file panel, including header-only pure renames from the large-PR reconstruction. - CodeView container gains diffshub's remaining perf CSS: overflow-anchor: none (native scroll anchoring fights CodeView's own anchor resolution whenever item heights change — exactly our augmentation applies), overflow-x-clip, and overflow-clip containment on item elements. * feat(review): worker-pool syntax highlighting (diffshub parity) A performance trace of scrolling a small local diff attributed 2.2s of 2.6s main-thread CPU to findNextMatchSync — shiki's TextMate regex scanner tokenizing on the main thread. diffshub avoids this entirely by running tokenization in Pierre's worker pool; we never opted in. Wires WorkerPoolContextProvider around the review app (pool size min(cores-1, 3), 100-entry AST LRU, common languages preloaded), gates the all-files surface on pool readiness with a 5s escape hatch (a dead pool degrades to plaintext-then-highlight, never a blank view), and syncs the UI theme pair into the long-lived pool. Single-file build constraint solved with Vite's ?worker&inline (base64 blob worker) + worker.format 'es' with inlineDynamicImports — the worker's lazy import("shiki/wasm") branch collapses into the bundle and is never taken (shiki-js engine: the win is moving work off the main thread, with no .wasm asset to smuggle into one HTML file). Bundle +850KB. * fix(review): un-poison worker-pool theme dedup on failed setRenderOptions A failed round-trip recorded the theme as synced and never retried, pinning the pool to the wrong palette for the session. * fix(review): report partial diffs without a checkout; fail fast on missing checkout Dogfood review of this PR (via plannotator itself) caught two valid issues: - prPatchIncomplete was gated on the worktree pool, so a --no-local session showed a truncated diff with no indication at all. Partiality is information; upgradability is a capability. The flag is now always reported, with a separate prPatchUpgradeAvailable — the UI shows the amber notice either way, with the "Load full diff" button only when a checkout can exist (otherwise a "re-run with --local" hint). - After a FAILED checkout warmup, Ask AI sessions and agent jobs fell back to process.cwd() (or a wrong revision on Pi) — running in the wrong tree instead of failing. Both launch points now refuse with a clear "Local PR checkout unavailable — retry shortly" error (503); the job handlers surface buildCommand refusals instead of mislabeling them "Invalid JSON". Bun and Pi mirrored. A third finding (sem availability stuck after warmup) was triaged invalid: the availability probe detects the sem binary, which is cwd-independent. * fix(review): runtime-neutral copy for the no-checkout partial-diff hint --local is a CLI remedy; OpenCode sessions have no such flag. Visible text states the fact, the tooltip carries the CLI guidance.	2026-06-12 13:50:09 -07:00
Michael Ramos	afac44b940	feat(review): migrate all-files code review to Pierre CodeView (#885) ... Replaces the all-files renderer with Pierre's virtualized CodeView (one scroller, identical look, scales to huge diffs); deletes the legacy AllFilesDiffView/LazyFileDiff and their flag; single-file panels stay on FileDiff. @pierre/diffs pinned exact 1.2.8 (1.2.9's tree is broken on npm — see #880). Also ships: diff staleness detection ('Diff out of date · Refresh' toolbar notice backed by shared per-VCS fingerprints + GET /api/diff/fresh on both Bun and Pi servers), a stale-content guard so files edited mid-review degrade to raw-patch view instead of breaking virtualization, the Ask AI wrong-file fix (pre-existing), and toolbar/header UI polish (global settings cog, aligned sem badges, no all-files split dragger). Hardened through five review waves; tested with 1384 passing tests incl. real-git fingerprint and patch-consistency suites. Known minor gaps documented in the PR.	2026-06-10 21:07:58 -07:00