diff --git a/packages/app/e2e/regression/review.spec.ts b/packages/app/e2e/regression/review.spec.ts index 48436187c2f..23c98c09a30 100644 --- a/packages/app/e2e/regression/review.spec.ts +++ b/packages/app/e2e/regression/review.spec.ts @@ -1786,6 +1786,29 @@ test("desktop review waits for the session's stored mode before it loads changes expect(working).toEqual([]) }) +// A failed request used to settle like an empty one, so the review claimed the working tree was clean. +test("a failed diff request offers a retry instead of a clean working tree", async ({ page }) => { + await openSession(page, { name: "ReviewDiffFailure", vcsDiff: [fileDiff("src/alpha.ts")] }) + const changes = { failing: true } + await page.route(/\/api\/vcs\/diff\?/, (route) => { + if (!changes.failing || new URL(route.request().url()).searchParams.get("untracked") !== "folders") + return route.fallback() + + return route.fulfill({ status: 500, headers: { "access-control-allow-origin": "*" }, json: {} }) + }) + const panel = page.locator("#review-panel") + const failure = panel.getByRole("alert") + + await page.getByRole("button", { name: "Toggle review", exact: true }).click() + await openReviewLauncher(panel) + await expect(failure.getByText("Couldn't load changes", { exact: true })).toBeVisible() + await expect(panel.locator('[data-slot="session-review-v2-empty-changes"]')).toHaveCount(0) + changes.failing = false + await failure.getByRole("button", { name: "Try again", exact: true }).click() + await expect(panel.locator('[data-slot="session-review-v2-file-name"]')).toHaveText("alpha.ts") + await expect(failure).toHaveCount(0) +}) + test("a chosen mode the session stops offering shows as Git, and comes back when it is offered again", async ({ page, }) => { diff --git a/packages/gui-plugins/src/review/i18n/en.ts b/packages/gui-plugins/src/review/i18n/en.ts index 4c842edc233..db0e35264ad 100644 --- a/packages/gui-plugins/src/review/i18n/en.ts +++ b/packages/gui-plugins/src/review/i18n/en.ts @@ -14,6 +14,9 @@ export default { "git.description": "Track, review, and undo changes in this project", loadingChanges: "Loading changes…", noChanges: "No changes", + "load.failed": "Couldn't load changes", + "load.timeout": "The server took too long to answer", + offline: "Can't reach this server", "settings.wrapLines.title": "Wrap lines", "settings.wrapLines.description": "Wrap long lines in mobile diffs instead of scrolling horizontally", } diff --git a/packages/gui-plugins/src/review/machine.test.ts b/packages/gui-plugins/src/review/machine.test.ts new file mode 100644 index 00000000000..cbdbce1a4fe --- /dev/null +++ b/packages/gui-plugins/src/review/machine.test.ts @@ -0,0 +1,319 @@ +import { describe, expect, test } from "bun:test" +import type { FileDiffInfo } from "@opencode/client/promise" +import { + INITIAL_REVIEW_DIFF_STATE, + reviewDiffReady, + reviewDiffView, + transitionReviewDiff, + type ReviewDiffContext, + type ReviewDiffEffect, + type ReviewDiffEvent, + type ReviewDiffState, + type ReviewDiffTarget, +} from "./machine" + +const git: ReviewDiffTarget = { + kind: "vcs", + serverID: "local", + directory: "C:/repo", + mode: "git", + branch: "feature", + defaultBranch: "dev", +} + +const branch: ReviewDiffTarget = { ...git, mode: "branch" } + +const turn: ReviewDiffTarget = { kind: "turn", serverID: "local", sessionID: "ses_1" } + +const alpha: FileDiffInfo[] = [{ file: "src/alpha.ts", patch: "", additions: 1, deletions: 0, status: "modified" }] + +const beta: FileDiffInfo[] = [{ file: "src/beta.ts", patch: "", additions: 2, deletions: 1, status: "modified" }] + +function ready(target: ReviewDiffTarget, input: { connected?: boolean; demanded?: boolean } = {}): ReviewDiffEvent { + const context: ReviewDiffContext = { + kind: "ready", + target, + connected: input.connected ?? true, + demanded: input.demanded ?? true, + } + + return { type: "context.changed", context } +} + +// Replays events through the pure machine and collects every effect it asked for, in order. +function play(state: ReviewDiffState, ...events: ReviewDiffEvent[]) { + return events.reduce<{ state: ReviewDiffState; effects: readonly ReviewDiffEffect[] }>( + (result, event) => { + const next = transitionReviewDiff(result.state, event) + + return { state: next.state, effects: [...result.effects, ...next.effects] } + }, + { state, effects: [] }, + ) +} + +// The review panel shows Git changes that loaded as attempt 1. +function loaded() { + return play(INITIAL_REVIEW_DIFF_STATE, ready(git), { + type: "fetch.succeeded", + attempt: 1, + rows: { rows: alpha, version: 10 }, + }).state +} + +describe("a request that fails", () => { + test("shows the failure with a retry instead of a clean working tree", () => { + const failed = play(INITIAL_REVIEW_DIFF_STATE, ready(git), { + type: "fetch.failed", + attempt: 1, + message: "git failed", + }) + + expect(failed.effects).toEqual([{ type: "fetch", target: git, attempt: 1 }]) + expect(reviewDiffView(failed.state)).toEqual({ + status: "error", + failure: { type: "rejected", message: "git failed" }, + }) + expect(reviewDiffReady(failed.state)).toBe(false) + + const retried = play( + failed.state, + { type: "retry" }, + { + type: "fetch.succeeded", + attempt: 2, + rows: { rows: alpha, version: 20 }, + }, + ) + + expect(retried.effects).toEqual([{ type: "fetch", target: git, attempt: 2 }]) + expect(reviewDiffView(retried.state)).toEqual({ status: "ready", rows: alpha, version: 20 }) + expect(reviewDiffReady(retried.state)).toBe(true) + }) + + test("times out instead of loading forever, and a timed-out refresh keeps the diffs shown", () => { + const timedOut = play(INITIAL_REVIEW_DIFF_STATE, ready(git), { type: "fetch.timed-out", attempt: 1 }).state + + expect(reviewDiffView(timedOut)).toEqual({ status: "error", failure: { type: "timeout" } }) + + const refreshed = play(loaded(), { type: "refresh", source: "vcs" }, { type: "fetch.timed-out", attempt: 2 }) + + expect(refreshed.effects).toEqual([{ type: "fetch", target: git, attempt: 2 }]) + expect(reviewDiffView(refreshed.state)).toEqual({ status: "ready", rows: alpha, version: 10 }) + }) + + test("a failed refresh keeps the diffs shown", () => { + const state = play( + loaded(), + { type: "window.focused" }, + { type: "fetch.failed", attempt: 2, message: "boom" }, + ).state + + expect(reviewDiffView(state)).toEqual({ status: "ready", rows: alpha, version: 10 }) + }) + + test("a retry outside a failure does nothing", () => { + const state = loaded() + + expect(transitionReviewDiff(state, { type: "retry" }).state).toBe(state) + }) +}) + +describe("a disconnected server", () => { + test("shows offline instead of loading forever, and loads once it reconnects", () => { + const unresolved = play(INITIAL_REVIEW_DIFF_STATE, { type: "context.changed", context: { kind: "offline" } }) + + expect(reviewDiffView(unresolved.state)).toEqual({ status: "offline" }) + expect(unresolved.effects).toEqual([]) + + const offline = play(unresolved.state, ready(git, { connected: false })) + + expect(reviewDiffView(offline.state)).toEqual({ status: "offline" }) + expect(offline.effects).toEqual([]) + + const reconnected = play(offline.state, ready(git)) + + expect(reviewDiffView(reconnected.state)).toEqual({ status: "loading" }) + expect(reconnected.effects).toEqual([{ type: "fetch", target: git, attempt: 1 }]) + }) + + test("a disconnect ends the request and drops its late answer", () => { + const state = play(INITIAL_REVIEW_DIFF_STATE, ready(git), ready(git, { connected: false }), { + type: "fetch.succeeded", + attempt: 1, + rows: { rows: alpha, version: 10 }, + }) + + expect(state.effects).toEqual([{ type: "fetch", target: git, attempt: 1 }, { type: "abort" }]) + expect(reviewDiffView(state.state)).toEqual({ status: "offline" }) + }) + + test("keeps loaded diffs while disconnected and refreshes them on reconnect", () => { + const disconnected = play(loaded(), ready(git, { connected: false })) + + expect(reviewDiffView(disconnected.state)).toEqual({ status: "ready", rows: alpha, version: 10 }) + expect(transitionReviewDiff(disconnected.state, { type: "side.opened" }).state).toBe(disconnected.state) + + const reconnected = play(disconnected.state, ready(git)) + + expect(reconnected.effects).toEqual([{ type: "fetch", target: git, attempt: 2 }]) + expect(reviewDiffView(reconnected.state)).toEqual({ status: "ready", rows: alpha, version: 10 }) + }) +}) + +describe("the side region opening", () => { + test("waits for the session store before it requests the stored mode", () => { + const waiting = play(INITIAL_REVIEW_DIFF_STATE, { type: "context.changed", context: { kind: "waiting" } }).state + const opened = transitionReviewDiff(waiting, { type: "side.opened" }) + + expect(opened.state).toBe(waiting) + expect(opened.effects).toEqual([]) + + const idle = play(waiting, ready(branch, { demanded: false }), { type: "side.opened" }) + + expect(idle.effects).toEqual([{ type: "fetch", target: branch, attempt: 1 }]) + }) + + test("does not request again while a request runs", () => { + const loading = play(INITIAL_REVIEW_DIFF_STATE, ready(git)).state + + expect(transitionReviewDiff(loading, { type: "side.opened" }).state).toBe(loading) + }) +}) + +describe("another target", () => { + test("aborts the running request and drops its answers", () => { + const switched = play( + INITIAL_REVIEW_DIFF_STATE, + ready(git), + ready(branch), + { type: "fetch.succeeded", attempt: 1, rows: { rows: alpha, version: 10 } }, + { type: "fetch.failed", attempt: 1, message: "aborted" }, + ) + + expect(switched.effects).toEqual([ + { type: "fetch", target: git, attempt: 1 }, + { type: "abort" }, + { type: "fetch", target: branch, attempt: 2 }, + ]) + expect(reviewDiffView(switched.state)).toEqual({ status: "loading" }) + + const settled = play(switched.state, { type: "fetch.succeeded", attempt: 2, rows: { rows: beta, version: 20 } }) + + expect(reviewDiffView(settled.state)).toEqual({ status: "ready", rows: beta, version: 20 }) + }) + + test("shows what an earlier request loaded for it while it loads again", () => { + const state = play(loaded(), { + type: "context.changed", + context: { kind: "ready", target: branch, connected: true, demanded: true, cached: { rows: beta, version: 5 } }, + }) + + expect(state.effects).toEqual([{ type: "fetch", target: branch, attempt: 2 }]) + expect(reviewDiffView(state.state)).toEqual({ status: "ready", rows: beta, version: 5 }) + }) + + test("never carries the previous target's failure", () => { + const failed = play(INITIAL_REVIEW_DIFF_STATE, ready(git), { type: "fetch.failed", attempt: 1, message: "boom" }) + const switched = play(failed.state, ready(turn)) + + expect(reviewDiffView(switched.state)).toEqual({ status: "loading" }) + }) +}) + +describe("background refreshes", () => { + test("follow the source that changed while something shows the changes", () => { + const state = loaded() + + expect(play(state, { type: "refresh", source: "vcs" }).effects).toEqual([ + { type: "fetch", target: git, attempt: 2 }, + ]) + expect(transitionReviewDiff(state, { type: "refresh", source: "turn" }).state).toBe(state) + + const hidden = play(state, ready(git, { demanded: false })).state + + expect(transitionReviewDiff(hidden, { type: "refresh", source: "vcs" }).state).toBe(hidden) + expect(transitionReviewDiff(hidden, { type: "window.focused" }).state).toBe(hidden) + expect(play(hidden, ready(git)).effects).toEqual([{ type: "fetch", target: git, attempt: 2 }]) + }) + + test("a focused window refreshes Git changes but not a finished turn", () => { + const changes = play(INITIAL_REVIEW_DIFF_STATE, ready(turn), { + type: "fetch.succeeded", + attempt: 1, + rows: { rows: alpha, version: 10 }, + }).state + + expect(transitionReviewDiff(changes, { type: "window.focused" }).state).toBe(changes) + expect(play(changes, { type: "refresh", source: "turn" }).effects).toEqual([ + { type: "fetch", target: turn, attempt: 2 }, + ]) + }) + + test("files that keep changing during the first load cannot hold it off: it keeps its request, then loads once more", () => { + const changing = play( + INITIAL_REVIEW_DIFF_STATE, + ready(git), + ...Array.from({ length: 5 }, (): ReviewDiffEvent => ({ type: "refresh", source: "vcs" })), + ) + + expect(changing.effects).toEqual([{ type: "fetch", target: git, attempt: 1 }]) + + const settled = play(changing.state, { type: "fetch.succeeded", attempt: 1, rows: { rows: alpha, version: 10 } }) + + expect(settled.effects).toEqual([{ type: "fetch", target: git, attempt: 2 }]) + expect(reviewDiffView(settled.state)).toEqual({ status: "ready", rows: alpha, version: 10 }) + + const final = play(settled.state, { type: "fetch.succeeded", attempt: 2, rows: { rows: beta, version: 20 } }) + + expect(final.effects).toEqual([]) + expect(reviewDiffView(final.state)).toEqual({ status: "ready", rows: beta, version: 20 }) + }) + + test("the first load still times out while files keep changing", () => { + const state = play( + INITIAL_REVIEW_DIFF_STATE, + ready(git), + { type: "refresh", source: "vcs" }, + { type: "refresh", source: "vcs" }, + { type: "fetch.timed-out", attempt: 1 }, + ) + + expect(state.effects).toEqual([{ type: "fetch", target: git, attempt: 1 }]) + expect(reviewDiffView(state.state)).toEqual({ status: "error", failure: { type: "timeout" } }) + }) + + test("a change while shown diffs refresh restarts the refresh", () => { + const state = play(loaded(), { type: "refresh", source: "vcs" }, { type: "refresh", source: "vcs" }) + + expect(state.effects).toEqual([ + { type: "fetch", target: git, attempt: 2 }, + { type: "abort" }, + { type: "fetch", target: git, attempt: 3 }, + ]) + }) +}) + +test("disposal aborts the running request and ignores every later event", () => { + const disposed = play(INITIAL_REVIEW_DIFF_STATE, ready(git), { type: "disposed" }) + + expect(disposed.effects).toEqual([{ type: "fetch", target: git, attempt: 1 }, { type: "abort" }]) + + const late = play( + disposed.state, + { type: "fetch.succeeded", attempt: 1, rows: { rows: alpha, version: 10 } }, + ready(branch), + { type: "retry" }, + ) + + expect(late.state).toBe(disposed.state) + expect(late.effects).toEqual([]) +}) + +test("a project without a repository is ready without a request", () => { + const state = play(loaded(), { type: "context.changed", context: { kind: "no-vcs" } }) + + expect(state.effects).toEqual([]) + expect(reviewDiffView(state.state)).toEqual({ status: "no-vcs" }) + expect(reviewDiffReady(state.state)).toBe(true) +}) diff --git a/packages/gui-plugins/src/review/machine.ts b/packages/gui-plugins/src/review/machine.ts new file mode 100644 index 00000000000..03be4274c48 --- /dev/null +++ b/packages/gui-plugins/src/review/machine.ts @@ -0,0 +1,274 @@ +import type { FileDiffInfo } from "@opencode/client/promise" + +/** How long a diff request may run before the review shows it failed, so a wedged server never loads forever. */ +export const REVIEW_DIFF_TIMEOUT_MS = 30_000 + +/** What one diff request reads: a directory's changes against the working tree or branch, or a session's last turn. */ +export type ReviewDiffTarget = + | { + readonly kind: "vcs" + readonly serverID: string + readonly directory: string + readonly mode: "git" | "branch" + readonly branch: string + readonly defaultBranch: string + } + | { readonly kind: "turn"; readonly serverID: string; readonly sessionID: string } + +/** Diffs loaded once for a target, with the version that tells their detail requests apart. */ +export type ReviewDiffRows = { readonly rows: readonly FileDiffInfo[]; readonly version: number } + +/** What the routed session lets the review request. */ +export type ReviewDiffContext = + /** The session store has not loaded, or the connected server has not sent the project: the mode is not known yet. */ + | { readonly kind: "waiting" } + /** The project has no repository. */ + | { readonly kind: "no-vcs" } + /** The server is disconnected before it sent the project. */ + | { readonly kind: "offline" } + | { + readonly kind: "ready" + readonly target: ReviewDiffTarget + readonly connected: boolean + /** Something shows the changes: the review panel, a change tree or file markers. */ + readonly demanded: boolean + /** Diffs an earlier request loaded for this target, shown while they load again. */ + readonly cached?: ReviewDiffRows + } + +export type ReviewDiffFailure = { readonly type: "rejected"; readonly message: string } | { readonly type: "timeout" } + +type Link = { + readonly target: ReviewDiffTarget + readonly connected: boolean + readonly demanded: boolean + /** The last request's number; a result for any other number is stale. */ + readonly attempt: number +} + +export type ReviewDiffState = + | { readonly status: "waiting"; readonly attempt: number } + | { readonly status: "no-vcs"; readonly attempt: number } + | { readonly status: "offline"; readonly attempt: number } + /** Nothing loaded and no request running: the server is disconnected, or nothing shows the changes. */ + | (Link & { readonly status: "idle" }) + /** `stale`: files changed while it loads; one more request follows its answer. */ + | (Link & { readonly status: "loading"; readonly stale: boolean }) + | (Link & { readonly status: "ready" } & ReviewDiffRows) + /** Loads again while the diffs already loaded stay shown. */ + | (Link & { readonly status: "refreshing" } & ReviewDiffRows) + | (Link & { readonly status: "error"; readonly failure: ReviewDiffFailure }) + | { readonly status: "disposed"; readonly attempt: number } + +export type ReviewDiffEvent = + | { readonly type: "context.changed"; readonly context: ReviewDiffContext } + /** The side region opened on a wide screen; loads the changes once so the review tab can count them. */ + | { readonly type: "side.opened" } + | { readonly type: "window.focused" } + /** Files changed in the directory (`vcs`), or the session finished a turn (`turn`). */ + | { readonly type: "refresh"; readonly source: ReviewDiffTarget["kind"] } + | { readonly type: "retry" } + | { readonly type: "fetch.succeeded"; readonly attempt: number; readonly rows: ReviewDiffRows } + | { readonly type: "fetch.failed"; readonly attempt: number; readonly message: string } + | { readonly type: "fetch.timed-out"; readonly attempt: number } + | { readonly type: "disposed" } + +export type ReviewDiffEffect = + /** Starts a request, replacing any running one. */ + { readonly type: "fetch"; readonly target: ReviewDiffTarget; readonly attempt: number } | { readonly type: "abort" } + +export type ReviewDiffTransition = { readonly state: ReviewDiffState; readonly effects: readonly ReviewDiffEffect[] } + +/** What the review panel shows. */ +export type ReviewDiffView = + | { readonly status: "loading" } + | { readonly status: "offline" } + | { readonly status: "no-vcs" } + | { readonly status: "error"; readonly failure: ReviewDiffFailure } + | ({ readonly status: "ready" } & ReviewDiffRows) + +type Linked = Extract + +export const INITIAL_REVIEW_DIFF_STATE: ReviewDiffState = { status: "waiting", attempt: 0 } + +const LOADING: ReviewDiffView = { status: "loading" } + +const OFFLINE: ReviewDiffView = { status: "offline" } + +const NO_VCS: ReviewDiffView = { status: "no-vcs" } + +const NONE: readonly ReviewDiffEffect[] = [] + +const ABORT: readonly ReviewDiffEffect[] = [{ type: "abort" }] + +export function transitionReviewDiff(state: ReviewDiffState, event: ReviewDiffEvent): ReviewDiffTransition { + if (state.status === "disposed") return unchanged(state) + + if (event.type === "disposed") return leave(state, { status: "disposed", attempt: state.attempt }) + + if (event.type === "context.changed") return contextChanged(state, event.context) + + if (!linked(state)) return unchanged(state) + + const enabled = state.connected && state.demanded + + // Loads even while nothing shows the changes, so the review tab can count them. + if (event.type === "side.opened") + return state.connected && !inFlight(state) ? fetch(state, state, rowsOf(state)) : unchanged(state) + + if (event.type === "window.focused") + return enabled && state.target.kind === "vcs" && (state.status === "ready" || state.status === "error") + ? fetch(state, state, rowsOf(state)) + : unchanged(state) + + if (event.type === "refresh") { + if (!enabled || state.target.kind !== event.source) return unchanged(state) + + // The first load keeps its request and deadline, so files that keep changing cannot hold it off forever. + if (state.status === "loading") return state.stale ? unchanged(state) : changed({ ...state, stale: true }) + + // Shown diffs refresh at once, so the answer cannot predate the change. + return fetch(state, state, rowsOf(state)) + } + + if (event.type === "retry") + return state.status === "error" && state.connected ? fetch(state, state, undefined) : unchanged(state) + + if (!inFlight(state) || event.attempt !== state.attempt) return unchanged(state) + + if (event.type === "fetch.succeeded") { + if (state.status !== "loading" || !state.stale) return changed({ ...link(state), status: "ready", ...event.rows }) + const attempt = state.attempt + 1 + + // The changes that arrived meanwhile load once more, with the first answer shown. + return { + state: { ...link(state), attempt, status: "refreshing", ...event.rows }, + effects: [{ type: "fetch", target: state.target, attempt }], + } + } + + // A failed refresh keeps the diffs already shown. A failed first load shows the failure; Try again loads the changes + // that arrived meanwhile too. + if (state.status === "refreshing") + return changed({ ...link(state), status: "ready", rows: state.rows, version: state.version }) + + return changed({ + ...link(state), + status: "error", + failure: event.type === "fetch.timed-out" ? { type: "timeout" } : { type: "rejected", message: event.message }, + }) +} + +export function reviewDiffView(state: ReviewDiffState): ReviewDiffView { + if (state.status === "offline") return OFFLINE + + if (state.status === "no-vcs") return NO_VCS + + if (state.status === "idle") return state.connected ? LOADING : OFFLINE + + if (state.status === "error") return { status: "error", failure: state.failure } + + if (state.status === "ready" || state.status === "refreshing") + return { status: "ready", rows: state.rows, version: state.version } + + return LOADING +} + +/** Whether the review knows what to show: diffs, or that the project has no repository. */ +export function reviewDiffReady(state: ReviewDiffState) { + return state.status === "ready" || state.status === "refreshing" || state.status === "no-vcs" +} + +export function sameReviewDiffTarget(a: ReviewDiffTarget, b: ReviewDiffTarget) { + if (a.kind === "turn") return b.kind === "turn" && a.serverID === b.serverID && a.sessionID === b.sessionID + + if (b.kind === "turn") return false + + return ( + a.serverID === b.serverID && + a.directory === b.directory && + a.mode === b.mode && + a.branch === b.branch && + a.defaultBranch === b.defaultBranch + ) +} + +function contextChanged(state: Exclude, context: ReviewDiffContext) { + if (context.kind !== "ready") + return state.status === context.kind + ? unchanged(state) + : leave(state, { status: context.kind, attempt: state.attempt }) + + const next: Link = { + target: context.target, + connected: context.connected, + demanded: context.demanded, + attempt: state.attempt, + } + + const enabled = next.connected && next.demanded + + // Another target starts over from what an earlier request loaded for it, if anything. + if (!linked(state) || !sameReviewDiffTarget(state.target, next.target)) { + if (enabled) return fetch(state, next, context.cached) + + return leave(state, context.cached ? { ...next, status: "ready", ...context.cached } : { ...next, status: "idle" }) + } + + if (state.connected === next.connected && state.demanded === next.demanded) return unchanged(state) + + // A disconnect ends the request; what loaded stays shown. + if (!next.connected) { + const rows = rowsOf(state) + + return leave(state, rows ? { ...next, status: "ready", ...rows } : { ...next, status: "idle" }) + } + + // Becoming shown, or reconnecting while shown, loads again. + if (enabled && !(state.connected && state.demanded) && !inFlight(state)) return fetch(state, next, rowsOf(state)) + + return changed({ ...state, connected: next.connected, demanded: next.demanded }) +} + +function fetch(state: ReviewDiffState, next: Link, rows: ReviewDiffRows | undefined): ReviewDiffTransition { + const attempt = state.attempt + 1 + const start: ReviewDiffEffect = { type: "fetch", target: next.target, attempt } + + return { + state: rows + ? { ...link(next), attempt, status: "refreshing", ...rows } + : { ...link(next), attempt, status: "loading", stale: false }, + effects: inFlight(state) ? [...ABORT, start] : [start], + } +} + +/** Moves to a state that runs no request, ending the running one. */ +function leave(state: ReviewDiffState, next: ReviewDiffState): ReviewDiffTransition { + return { state: next, effects: inFlight(state) ? ABORT : NONE } +} + +function link(state: Link): Link { + return { target: state.target, connected: state.connected, demanded: state.demanded, attempt: state.attempt } +} + +function linked(state: ReviewDiffState): state is Linked { + return "target" in state +} + +function inFlight(state: ReviewDiffState) { + return state.status === "loading" || state.status === "refreshing" +} + +function rowsOf(state: ReviewDiffState): ReviewDiffRows | undefined { + if (state.status !== "ready" && state.status !== "refreshing") return undefined + + return { rows: state.rows, version: state.version } +} + +function changed(state: ReviewDiffState): ReviewDiffTransition { + return { state, effects: NONE } +} + +function unchanged(state: ReviewDiffState): ReviewDiffTransition { + return { state, effects: NONE } +} diff --git a/packages/gui-plugins/src/review/model.ts b/packages/gui-plugins/src/review/model.ts index 15273685c2f..87f34b9a29b 100644 --- a/packages/gui-plugins/src/review/model.ts +++ b/packages/gui-plugins/src/review/model.ts @@ -5,7 +5,7 @@ import { artifactMime } from "@opencode/util/artifact" import { bytesToBase64 } from "@opencode/util/base64" import { checksum } from "@opencode/util/encode" import { showToast } from "@opencode/ui/toast" -import { createQuery, useQueries, useQueryClient } from "@tanstack/solid-query" +import { createQuery, focusManager, useQueries, useQueryClient } from "@tanstack/solid-query" import { debounce } from "@solid-primitives/scheduled" import { createMemo, createSignal, on, onCleanup, untrack, type Accessor } from "solid-js" import { createStore } from "solid-js/store" @@ -36,6 +36,21 @@ import { type ReviewScrollEvent, type ReviewScrollState, } from "./scroll-machine" +import { + INITIAL_REVIEW_DIFF_STATE, + REVIEW_DIFF_TIMEOUT_MS, + reviewDiffReady, + reviewDiffView, + sameReviewDiffTarget, + transitionReviewDiff, + type ReviewDiffContext, + type ReviewDiffEffect, + type ReviewDiffEvent, + type ReviewDiffRows, + type ReviewDiffState, + type ReviewDiffTarget, + type ReviewDiffView, +} from "./machine" export type ChangeMode = "git" | "branch" | "turn" @@ -46,6 +61,9 @@ export type Demand = { tree: number; files: number; panel: number; details: numb /** The narrow review's list and the animation frame that scrolls it to a focused file. */ type ScrollTarget = { element?: HTMLDivElement; frame?: number } +/** The diff request the driver runs: its abort controller and its timeout. */ +type DiffRequest = { controller?: AbortController; timer?: ReturnType } + const selectionFromLines = (range: LineRange): FileSelection => ({ startLine: Math.min(range.start, range.end), endLine: Math.max(range.start, range.end), @@ -161,29 +179,122 @@ export function createReviewModel(input: { const turnKey = () => [ctx.id, view().server.id, "session-turn", view().id] as const - const diffQuery = createQuery(() => { - const value = mode() - const turn = value === "turn" + const diffContext = createMemo( + (): ReviewDiffContext => { + const project = view().project + + if (project && !project.vcs) return { kind: "no-vcs" } - return { - queryKey: turn ? turnKey() : ([...vcsKey(), value] as const), // Desktop storage loads asynchronously; until this session's mode is known, a request would use the default. - enabled: !!stored() && view().server.connected && wantsReview() && !!view().project?.vcs, - refetchOnMount: "always" as const, - // A finished turn does not change on focus or filesystem events; refresh it when the session goes idle. - refetchOnWindowFocus: !turn, - queryFn: turn - ? () => view().server.client.session.diff({ sessionID: view().id }) - : () => - view() - .server.client.vcs.diff({ - location: { directory: directory() }, - mode: value === "git" ? "working" : value, - untracked: "folders", - }) - .then((result) => result.data), - } - }) + if (!stored()) return { kind: "waiting" } + const connected = view().server.connected + + if (!project) return connected ? { kind: "waiting" } : { kind: "offline" } + const value = mode() + const serverID = view().server.id + + const target: ReviewDiffTarget = + value === "turn" + ? { kind: "turn", serverID, sessionID: view().id } + : { + kind: "vcs", + serverID, + directory: directory(), + mode: value, + branch: vcs()?.branch.current ?? "", + defaultBranch: vcs()?.branch.default ?? "", + } + + return { kind: "ready", target, connected, demanded: wantsReview() } + }, + undefined, + { equals: sameDiffContext }, + ) + + const [diffState, setDiffState] = createSignal(INITIAL_REVIEW_DIFF_STATE) + const diffRequest: DiffRequest = {} + + // The diffs a target last loaded stay in the query cache, so returning to a mode or directory shows them at once. + const diffKey = (target: ReviewDiffTarget) => + target.kind === "turn" + ? [ctx.id, target.serverID, "session-turn", target.sessionID] + : [ctx.id, target.serverID, "session-vcs", target.directory, target.branch, target.defaultBranch, target.mode] + + const dispatchDiff = (event: ReviewDiffEvent) => { + const next = transitionReviewDiff(untrack(diffState), event) + + setDiffState(next.state) + next.effects.forEach(runDiffEffect) + } + + const runDiffEffect = (effect: ReviewDiffEffect) => { + clearTimeout(diffRequest.timer) + diffRequest.controller?.abort() + + if (effect.type === "abort") return + const attempt = effect.attempt + const controller = new AbortController() + + const timer = setTimeout(() => { + controller.abort() + dispatchDiff({ type: "fetch.timed-out", attempt }) + }, REVIEW_DIFF_TIMEOUT_MS) + + diffRequest.controller = controller + diffRequest.timer = timer + // The machine drops the answer of a request it no longer waits for, aborted or not. + void requestDiff(effect.target, AbortSignal.any([ctx.signal, controller.signal])).then( + (rows) => { + clearTimeout(timer) + const loaded: ReviewDiffRows = { rows, version: Date.now() } + + queryClient.setQueryData(diffKey(effect.target), loaded) + dispatchDiff({ type: "fetch.succeeded", attempt, rows: loaded }) + }, + (cause: unknown) => { + clearTimeout(timer) + dispatchDiff({ type: "fetch.failed", attempt, message: cause instanceof Error ? cause.message : String(cause) }) + }, + ) + } + + const requestDiff = (target: ReviewDiffTarget, signal: AbortSignal) => { + const client = view().server.client + + if (target.kind === "turn") return client.session.diff({ sessionID: target.sessionID }, { signal }) + + return client.vcs + .diff( + { + location: { directory: target.directory }, + mode: target.mode === "git" ? "working" : target.mode, + untracked: "folders", + }, + { signal }, + ) + .then((result) => result.data) + } + + createKeyed(diffContext, (context) => + dispatchDiff({ + type: "context.changed", + context: + context.kind === "ready" + ? { ...context, cached: queryClient.getQueryData(diffKey(context.target)) } + : context, + }), + ) + + // A finished turn does not change on focus or filesystem events; the machine refreshes only Git changes then. + onCleanup( + focusManager.subscribe((focused) => { + if (focused) dispatchDiff({ type: "window.focused" }) + }), + ) + onCleanup(() => dispatchDiff({ type: "disposed" })) + + // A connection or demand change alone keeps the view, so the diffs it shows are not computed again. + const diffView = createMemo(() => reviewDiffView(diffState()), undefined, { equals: sameDiffView }) // The session details' changes row: the session directory's working tree, loaded only while the details show. const detailsKey = () => [ctx.id, view().server.id, "session-details", view().directory] as const @@ -203,6 +314,7 @@ export function createReviewModel(input: { })) const refresh = debounce(() => { + dispatchDiff({ type: "refresh", source: "vcs" }) void queryClient.invalidateQueries({ queryKey: vcsKey() }) void queryClient.invalidateQueries({ queryKey: detailsKey() }) }, 100) @@ -232,18 +344,22 @@ export function createReviewModel(input: { ) createKeyed(opened, () => { - if (diffQuery.isFetching) return - if (input.demand.tree > 0) { refresh() return } - if (view().server.connected && view().project?.vcs) void diffQuery.refetch() + dispatchDiff({ type: "side.opened" }) }) - const rows = (): FileDiffInfo[] => (diffQuery.isFetched ? (diffQuery.data ?? []) : []) + const noRows: readonly FileDiffInfo[] = [] + + const rows = () => { + const current = diffView() + + return current.status === "ready" ? current.rows : noRows + } // Git lists an untracked folder as one row. Once the change tree opens it, the folder lists its entries one level // deep; they stay loaded while it is closed again, until the changes' source changes. @@ -323,24 +439,9 @@ export function createReviewModel(input: { const count = () => rows().length const hasChanges = () => count() > 0 - const ready = () => { - // A project without VCS never enables diffQuery, so its status stays "pending" forever. - const project = view().project + const ready = () => reviewDiffReady(diffState()) - if (project && !project.vcs) return true - - if (!stored()) return false - - return !diffQuery.isPending - } - - const lifetime = { disposed: false } - - onCleanup(() => { - lifetime.disposed = true - }) - - const alive = () => !lifetime.disposed && !ctx.signal.aborted + const alive = () => untrack(diffState).status !== "disposed" && !ctx.signal.aborted // Initializes Git for the routed session. The request keeps that session's object, so its server and location stay // its own. Cache refresh follows the request's session; only error feedback depends on which session is routed. @@ -641,6 +742,7 @@ export function createReviewModel(input: { // A session that goes idle has finished its turn, which may have changed files. createKeyed(idled, () => { refresh() + dispatchDiff({ type: "refresh", source: "turn" }) void queryClient.invalidateQueries({ queryKey: turnKey() }) }) @@ -675,7 +777,13 @@ export function createReviewModel(input: { count, deferRender, details: (): FileDiffInfo[] | undefined => (detailsQuery.isFetched ? (detailsQuery.data ?? []) : undefined), - diffVersion: () => diffQuery.dataUpdatedAt, + /** What the review shows: diffs, or why there are none yet. */ + diff: diffView, + diffVersion: () => { + const current = diffView() + + return current.status === "ready" ? current.version : 0 + }, diffs, folderLabels, renderable, @@ -687,11 +795,6 @@ export function createReviewModel(input: { loadDiff, readFile, mode, - noGit: createMemo(() => { - const project = view().project - - return !!project && !project.vcs - }), filter: () => state.filter, setFilter: (value: string) => setState("filter", value), open: () => stored()?.open ?? [], @@ -706,6 +809,7 @@ export function createReviewModel(input: { options, panelRendered, ready, + retry: () => dispatchDiff({ type: "retry" }), setMode: (value: ChangeMode) => update((draft) => { draft.mode = value @@ -721,3 +825,22 @@ export function createReviewModel(input: { } export type ReviewModel = ReturnType + +function sameDiffContext(previous: ReviewDiffContext, next: ReviewDiffContext) { + if (previous.kind !== "ready" || next.kind !== "ready") return previous.kind === next.kind + + return ( + previous.connected === next.connected && + previous.demanded === next.demanded && + sameReviewDiffTarget(previous.target, next.target) + ) +} + +function sameDiffView(previous: ReviewDiffView, next: ReviewDiffView) { + if (previous.status === "ready" && next.status === "ready") + return previous.rows === next.rows && previous.version === next.version + + if (previous.status === "error" && next.status === "error") return previous.failure === next.failure + + return previous.status === next.status +} diff --git a/packages/gui-plugins/src/review/panel.tsx b/packages/gui-plugins/src/review/panel.tsx index 3220a2c98e3..218c98c49ad 100644 --- a/packages/gui-plugins/src/review/panel.tsx +++ b/packages/gui-plugins/src/review/panel.tsx @@ -1,4 +1,4 @@ -import { createMemo, createResource, createSignal, Show, type JSX } from "solid-js" +import { createMemo, createResource, createSignal, Match, Show, Switch, type JSX } from "solid-js" import { Dynamic } from "solid-js/web" import type { FileDiffInfo } from "@opencode/client/promise" import { @@ -32,6 +32,7 @@ import { sortReviewPaths, type RenderDiff, } from "./kinds" +import type { ReviewDiffView } from "./machine" import type { ReviewModel } from "./model" import { ReviewPanelEmpty, ReviewTitle } from "./parts" @@ -54,7 +55,7 @@ type ReviewPanelProps = { kinds: ReturnType /** Labels for opened untracked folders in the change tree. */ folderLabels?: ReadonlyMap - diffsReady: boolean + status: ReviewDiffView["status"] diffVersion?: number loadDiff?: (path: string, version?: number) => Promise readFile: ReviewModel["readFile"] @@ -92,7 +93,7 @@ export default function ReviewPanelContent(props: { diffs={props.review.renderable()} kinds={props.review.kinds()} folderLabels={props.review.folderLabels()} - diffsReady={props.review.ready()} + status={props.review.diff().status} diffVersion={props.review.diffVersion()} loadDiff={props.review.loadDiff} readFile={props.review.readFile} @@ -219,7 +220,7 @@ function ReviewPanel(props: ReviewPanelProps) { session={props.session} title={props.title} state={props.state} - diffsReady={props.diffsReady} + status={props.status} onSelectFile={props.onSelectFile} diffs={diffs()} filteredFiles={filteredFiles()} @@ -272,7 +273,7 @@ function ReviewPanelSidebar(props: { session: MountedSession title?: JSX.Element state: ReviewPanelState - diffsReady: boolean + status: ReviewDiffView["status"] onSelectFile: (path: string) => void diffs: RenderDiff[] filteredFiles: string[] @@ -326,58 +327,64 @@ function ReviewPanelSidebar(props: { minWidth={SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN} maxWidth={SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX} > - +
{ctx.t("common.loading")} {ctx.t("common.loading.ellipsis")}
- } - > - - {(views) => ( - - )} - - } - > +
+ +
{ctx.t("offline")}
+
+ +
{ctx.t("load.failed")}
+
+ 0} - fallback={
{ctx.t("palette.empty")}
} + when={props.searching} + fallback={ + + {(views) => ( + + )} + + } > - - {(views) => ( - { - setExplicitHighlight(path) - props.onSelectFile(path) - }} - /> - )} + 0} + fallback={
{ctx.t("palette.empty")}
} + > + + {(views) => ( + { + setExplicitHighlight(path) + props.onSelectFile(path) + }} + /> + )} +
-
-
+ + ) } diff --git a/packages/gui-plugins/src/review/parts.tsx b/packages/gui-plugins/src/review/parts.tsx index c1b6de31800..979f06e4c40 100644 --- a/packages/gui-plugins/src/review/parts.tsx +++ b/packages/gui-plugins/src/review/parts.tsx @@ -1,8 +1,10 @@ import { Match, Show, Switch } from "solid-js" import { SessionReviewEmptyChangesV2 } from "@opencode/session-ui/v2/session-review-empty-changes-v2" import { SessionReviewEmptyNoGitV2 } from "@opencode/session-ui/v2/session-review-empty-no-git-v2" +import { Button } from "@opencode/ui/button" import { Select } from "@opencode/ui/select" import { usePlugin } from "@opencode/plugin/gui" +import type Review from "./index" import type { ChangeMode, ReviewModel } from "./model" export function ReviewTitle(props: { review: ReviewModel }) { @@ -43,7 +45,6 @@ export function ReviewTitle(props: { review: ReviewModel }) { export function ReviewEmpty(props: { review: ReviewModel; loadingClass: string }) { const ctx = usePlugin() - const loading = () => !props.review.ready() const text = () => { if (props.review.mode() === "git") return ctx.t("empty.git") @@ -55,14 +56,19 @@ export function ReviewEmpty(props: { review: ReviewModel; loadingClass: string } return ( - +
{ctx.t("loadingChanges")}
- +
+ +
+ +
+
{text()}
@@ -74,19 +80,56 @@ export function ReviewEmpty(props: { review: ReviewModel; loadingClass: string } export function ReviewPanelEmpty(props: { review: ReviewModel }) { const ctx = usePlugin() - const loading = () => !props.review.ready() return ( - +
{ctx.t("loadingChanges")}
- + + +
+ +
+
) } + +/** Why the changes cannot show: the server is unreachable, or their request failed and can be retried. */ +function ReviewUnavailable(props: { review: ReviewModel }) { + const ctx = usePlugin() + + const failure = () => { + const current = props.review.diff() + + return current.status === "error" ? current.failure : undefined + } + + return ( + {ctx.t("offline")}
} + > + {(failure) => ( + + )} + + ) +} diff --git a/packages/plugin/src/gui/review.ts b/packages/plugin/src/gui/review.ts index 67bda2a2857..f41b9d66d01 100644 --- a/packages/plugin/src/gui/review.ts +++ b/packages/plugin/src/gui/review.ts @@ -20,7 +20,8 @@ export interface Changes { */ diffs(session: SessionRef): readonly FileDiffInfo[] /** - * False while the current mode's diffs load. + * True once the current mode's diffs loaded, or the project has no repository. False while they load, after their + * request failed or timed out, while the server is unreachable, and before anything requested them. * * @param session - The session to read. * @returns Whether the diffs loaded.