diff --git a/.github/labeler.yml b/.github/labeler.yml index 658018c89..fa39c467f 100644 --- a/.github/labeler.yml +++ b/.github/labeler.yml @@ -4,6 +4,11 @@ ci: - ".github/workflows/**" - ".github/**" +task: + - changed-files: + - any-glob-to-any-file: + - ".github/workflows/**" + platform: - changed-files: - any-glob-to-any-file: diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx index 9b26e8ea3..652eed8eb 100644 --- a/packages/app/src/pages/session.tsx +++ b/packages/app/src/pages/session.tsx @@ -24,6 +24,7 @@ import { useSessionLayout } from "@/pages/session/session-layout" import { SessionPageComposerRegion } from "@/pages/session/session-composer-region" import { SessionMainView } from "@/pages/session/session-main-view" import { createSessionRunning, isSessionRunning } from "@/pages/session/session-running-state" +import { createSessionTurnChanges } from "@/pages/session/session-turn-changes" import { useSessionCommands } from "@/pages/session/use-session-commands" import { createSessionCommentContext } from "@/pages/session/use-session-comment-context" import { useSessionDesktopContext } from "@/pages/session/use-session-desktop-context" @@ -125,6 +126,7 @@ export default function Page() { const timelineHistoryMore = timeline.historyMore const timelineHistoryLoading = timeline.historyLoading const lastUserMessage = timeline.lastUserMessage + const turnChangeController = createSessionTurnChanges({ sessionID: timelineSessionID, sessionMessages: timelineMessages }) const diagnostics = createSessionPageDiagnostics({ routeSessionID: () => params.id, timelineSessionID, @@ -174,7 +176,7 @@ export default function Page() { const [mobileTab, setMobileTab] = createSignal<"session" | "changes">("session") const deferRender = createSessionDeferredRender(timelineSessionKey) - const turnDiffs = timelineDiffs + const turnDiffs = () => [] const mobileChanges = createMemo(() => !isDesktop() && mobileTab() === "changes") const wantsReview = createMemo(() => isDesktop() ? desktopSidePanelOpen() && view().sidePanel.tab() === "review" : mobileChanges(), @@ -190,6 +192,10 @@ export default function Page() { executionScope: currentExecutionScope, sessionKey: timelineSessionKey, sessionID: timelineSessionID, + latestTurnChange: () => { + const id = lastUserMessage()?.id + return id ? turnChangeController.turnChanges[id] : undefined + }, sync, sdk, wantsReview, @@ -469,6 +475,7 @@ export default function Page() { timelineSessionKey={timelineSessionKey()} timelineMessagesReady={timelineMessagesReady()} timelineMessages={timelineMessages()} + turnChangeController={turnChangeController} mobileChanges={mobileChanges()} mobileFallback={reviewPanel.mobileFallback()} actions={actions} diff --git a/packages/app/src/pages/session/message-timeline.tsx b/packages/app/src/pages/session/message-timeline.tsx index 8866357ab..5cdb39418 100644 --- a/packages/app/src/pages/session/message-timeline.tsx +++ b/packages/app/src/pages/session/message-timeline.tsx @@ -38,7 +38,7 @@ import { SessionMessageComments, } from "@/pages/session/session-message-comments" import { buildTurnMessagesByUserID, emptyAssistantMessages } from "@/pages/session/session-messages" -import { createSessionTurnChanges } from "@/pages/session/session-turn-changes" +import type { createSessionTurnChanges } from "@/pages/session/session-turn-changes" import { createSessionRunning } from "@/pages/session/session-running-state" import { useLanguage } from "@/context/language" import { useSessionRouteKey } from "@/pages/session/session-layout" @@ -70,6 +70,7 @@ export function MessageTimeline(props: { sessionID: string sessionKey: string sessionMessages: MessageType[] + turnChangeController: ReturnType mobileChanges: boolean mobileFallback: JSX.Element actions?: UserActions @@ -151,7 +152,6 @@ export function MessageTimeline(props: { const sessionID = createMemo(() => props.sessionID) const sessionMessages = createMemo(() => props.sessionMessages) const turnMessagesByUserID = createMemo(() => buildTurnMessagesByUserID(sessionMessages())) - const turnChangeController = createSessionTurnChanges({ sessionID, sessionMessages }) const webSearchToastSurfaced = new Set() const webSearchPartCursor = new Map() const webSearchPendingParts = new Map>() @@ -321,9 +321,9 @@ export function MessageTimeline(props: { showReasoningSummaries={settings.general.showReasoningSummaries()} shellToolDefaultOpen={settings.general.shellToolPartsExpanded()} editToolDefaultOpen={settings.general.editToolPartsExpanded()} - turnChanges={turnChangeController.turnChanges} + turnChanges={props.turnChangeController.turnChanges} turnChangeActions={{ - ...turnChangeController.actions, + ...props.turnChangeController.actions, openFile: (path) => { void platform.openPath?.(path) }, diff --git a/packages/app/src/pages/session/session-main-view.tsx b/packages/app/src/pages/session/session-main-view.tsx index 090fda9bb..4f818c6b3 100644 --- a/packages/app/src/pages/session/session-main-view.tsx +++ b/packages/app/src/pages/session/session-main-view.tsx @@ -10,6 +10,7 @@ import { shouldShowSessionOpeningState } from "@/pages/session/session-main-view import type { createSessionHistoryWindow } from "@/pages/session/use-session-history-window" import type { createSessionReviewState } from "@/pages/session/use-session-review-state" import type { createSessionScrollDock } from "@/pages/session/use-session-scroll-dock" +import type { createSessionTurnChanges } from "@/pages/session/session-turn-changes" import { TimelineE2EDriverBoundary } from "@/testing/timeline" type TimelineProps = ComponentProps @@ -27,6 +28,7 @@ export function SessionMainView(props: { timelineSessionKey: string timelineMessagesReady: boolean timelineMessages: TimelineProps["sessionMessages"] + turnChangeController: ReturnType mobileChanges: boolean mobileFallback: JSX.Element actions: TimelineProps["actions"] @@ -141,6 +143,7 @@ export function SessionMainView(props: { sessionID={props.timelineSessionID ?? ""} sessionKey={props.timelineSessionKey} sessionMessages={props.timelineMessages} + turnChangeController={props.turnChangeController} mobileChanges={props.mobileChanges} mobileFallback={props.mobileFallback} actions={props.actions} diff --git a/packages/app/src/pages/session/use-session-review-state.test.ts b/packages/app/src/pages/session/use-session-review-state.test.ts index 1b5a7229e..ce5852890 100644 --- a/packages/app/src/pages/session/use-session-review-state.test.ts +++ b/packages/app/src/pages/session/use-session-review-state.test.ts @@ -1,6 +1,10 @@ import { describe, expect, test } from "bun:test" import { vcsTaskKey } from "./execution-scope" -import { deriveReviewArtifactFiles, reviewTurnDiffsForSession } from "./use-session-review-state" +import { + deriveReviewArtifactFiles, + selectReviewChangeMode, + turnChangeDisplayDiffs, +} from "./use-session-review-state" const scope = (directory = "/repo", epoch = 1) => ({ serverKey: "sidecar", directory, epoch }) @@ -93,29 +97,69 @@ describe("session review state", () => { expect(vcsTaskKey(scope("/repo", 3), "unstaged")).not.toBe(vcsTaskKey(scope("/repo", 3), "staged")) }) - test("does not reuse aggregate diffs across sessions or execution scopes", () => { - const aggregate = { + test("builds review turn diffs from the shared turn-change display", () => { + const diffs = turnChangeDisplayDiffs({ + kind: "captured", sessionID: "ses_1", - scope: scope("/repo", 1), - diffs: [{ file: "old-session.ts", patch: "", additions: 1, deletions: 0, status: "added" as const }], - } - const fallback = [{ file: "current-session.ts", patch: "", additions: 1, deletions: 0, status: "added" as const }] + turnID: "msg_user", + messageID: "msg_user", + files: [ + { + path: "base.txt", + openPath: "/repo/base.txt", + patch: "@@ -1 +1 @@", + status: "modified", + additions: 1, + deletions: 0, + expandable: true, + restoreState: "applied", + }, + { + path: "undone.txt", + patch: "", + status: "modified", + additions: 1, + deletions: 0, + expandable: true, + restoreState: "undone", + }, + ], + }) - expect( - reviewTurnDiffsForSession({ - currentScope: scope("/repo", 1), - sessionID: "ses_2", - aggregate, - turnDiffs: fallback, - }), - ).toEqual(fallback) - expect( - reviewTurnDiffsForSession({ - currentScope: scope("/repo", 2), - sessionID: "ses_1", - aggregate, - turnDiffs: fallback, - }), - ).toEqual(fallback) + expect(diffs).toEqual([ + { + file: "/repo/base.txt", + patch: "@@ -1 +1 @@", + additions: 1, + deletions: 0, + status: "modified", + }, + ]) + }) + + test("selecting a VCS review mode forces a reload even when cached", () => { + const loads: Array<{ mode: string; force: true }> = [] + const changes: string[] = [] + + selectReviewChangeMode({ + mode: "branch", + setChanges: (mode) => changes.push(mode), + wantsReview: () => true, + loadVcs: (mode, force) => { + loads.push({ mode, force }) + }, + }) + + selectReviewChangeMode({ + mode: "turn", + setChanges: (mode) => changes.push(mode), + wantsReview: () => true, + loadVcs: (mode, force) => { + loads.push({ mode, force }) + }, + }) + + expect(changes).toEqual(["branch", "turn"]) + expect(loads).toEqual([{ mode: "branch", force: true }]) }) }) diff --git a/packages/app/src/pages/session/use-session-review-state.ts b/packages/app/src/pages/session/use-session-review-state.ts index 3d46ee593..d0640ba89 100644 --- a/packages/app/src/pages/session/use-session-review-state.ts +++ b/packages/app/src/pages/session/use-session-review-state.ts @@ -1,9 +1,10 @@ import type { SnapshotFileDiff, VcsFileDiff } from "@opencode-ai/sdk/v2" -import { createEffect, createMemo, createResource, createSignal, on, onCleanup } from "solid-js" +import { createEffect, createMemo, createResource, createSignal, on, onCleanup, untrack } from "solid-js" import { createStore } from "solid-js/store" import type { useSDK } from "@/context/sdk" import type { useSync } from "@/context/sync" import { deriveArtifactFiles, type SessionArtifactFile } from "@/pages/session/files-tab-state" +import type { TurnChangeDisplay } from "@/pages/session/session-turn-changes" import { coerceReviewChangeMode, isVcsReviewMode, @@ -16,25 +17,33 @@ import { import { diffs as list } from "@/utils/diffs" import { same } from "@/utils/same" import { sameExecutionScope, shouldApplyExecutionResult, vcsTaskKey, type ExecutionScope } from "./execution-scope" -import { aggregateFiles } from "./session-aggregate-files" type SessionReviewDiff = SnapshotFileDiff | VcsFileDiff -type SessionAggregateDiffState = { sessionID: string; scope: ExecutionScope; diffs: SnapshotFileDiff[] } | undefined -export function reviewTurnDiffsForSession(input: { - currentScope: ExecutionScope - sessionID: string | undefined - aggregate: SessionAggregateDiffState - turnDiffs: SessionReviewDiff[] +export function selectReviewChangeMode(input: { + mode: ReviewChangeMode + setChanges: (mode: ReviewChangeMode) => void + wantsReview: () => boolean + loadVcs: (mode: VcsReviewMode, force: true) => void | Promise }) { - if ( - input.aggregate && - input.aggregate.sessionID === input.sessionID && - sameExecutionScope(input.aggregate.scope, input.currentScope) - ) { - return input.aggregate.diffs.length > 0 ? input.aggregate.diffs : input.turnDiffs - } - return input.turnDiffs + input.setChanges(input.mode) + if (!isVcsReviewMode(input.mode)) return + if (!input.wantsReview()) return + void input.loadVcs(input.mode, true) +} + +export function turnChangeDisplayDiffs(display: TurnChangeDisplay | null | undefined): SnapshotFileDiff[] { + if (!display) return [] + if (display.kind === "empty" || display.kind === "uncaptured") return [] + return display.files + .filter((file) => file.restoreState === "applied") + .map((file) => ({ + file: file.openPath ?? file.path, + patch: file.patch ?? "", + additions: file.additions ?? 0, + deletions: file.deletions ?? 0, + status: file.status, + })) } export function deriveReviewArtifactFiles(input: { @@ -68,14 +77,14 @@ export function createSessionReviewState(input: { executionScope: () => ExecutionScope sessionKey: () => string sessionID: () => string | undefined + latestTurnChange: () => TurnChangeDisplay | null | undefined sync: ReturnType sdk: ReturnType wantsReview: () => boolean turnDiffs: () => SessionReviewDiff[] artifactDiffs?: () => SessionReviewDiff[] }) { - const [changes, setChanges] = createSignal("turn") - const [sessionAggregateDiffs, setSessionAggregateDiffs] = createSignal() + const [changes, setChangesSignal] = createSignal("turn") const [vcs, setVcs] = createStore<{ diff: Record ready: Record @@ -167,6 +176,8 @@ export function createSessionReviewState(input: { vcsTask.set(key, task) return task } + const setChanges = (mode: ReviewChangeMode) => + selectReviewChangeMode({ mode, setChanges: setChangesSignal, wantsReview: input.wantsReview, loadVcs }) const changesOptions = createMemo(() => reviewChangeOptions({ isGit: input.sync.project?.vcs === "git" }), @@ -178,12 +189,7 @@ export function createSessionReviewState(input: { const reviewDiffs = createMemo(() => list( reviewDiffsForMode(changes(), { - turn: reviewTurnDiffsForSession({ - currentScope: input.executionScope(), - sessionID: input.sessionID(), - aggregate: sessionAggregateDiffs(), - turnDiffs: input.turnDiffs(), - }), + turn: turnChangeDisplayDiffs(input.latestTurnChange()), vcs: vcs.diff, }), ), @@ -249,8 +255,7 @@ export function createSessionReviewState(input: { on( input.sessionKey, () => { - setChanges(nextReviewModeForSessionChange()) - setSessionAggregateDiffs(undefined) + setChangesSignal(nextReviewModeForSessionChange()) }, { defer: true }, ), @@ -260,7 +265,7 @@ export function createSessionReviewState(input: { const options = changesOptions() const current = changes() const next = coerceReviewChangeMode(current, options) - if (next !== current) setChanges(next) + if (next !== current) setChangesSignal(next) }) createEffect(() => { @@ -270,6 +275,19 @@ export function createSessionReviewState(input: { void loadVcs(mode) }) + createEffect( + on( + input.wantsReview, + (wants) => { + if (!wants) return + const mode = untrack(vcsMode) + if (!mode) return + void loadVcs(mode, true) + }, + { defer: true }, + ), + ) + createEffect(() => { const id = input.sessionID() if (!id) return @@ -280,33 +298,10 @@ export function createSessionReviewState(input: { createEffect(() => { const id = input.sessionID() if (!id) return - const scope = input.executionScope() if (input.sync.data.turn_change_aggregate[id] === undefined) return - setSessionAggregateDiffs({ sessionID: id, scope, diffs: aggregateFiles(input.sync.data.turn_change_aggregate[id]) }) queueArtifactHistoryRefetch() }) - createEffect(() => { - const id = input.sessionID() - if (!id) return - if (!input.wantsReview()) return - const scope = input.executionScope() - void input.sdk - .createClient({ directory: scope.directory, throwOnError: true }) - .session.diff({ sessionID: id }) - .then((res) => { - if (input.sessionID() !== id) return - if (!shouldApplyExecutionResult({ requested: scope, current: input.executionScope() })) return - setSessionAggregateDiffs({ sessionID: id, scope, diffs: aggregateFiles(res.data) }) - }) - .catch((error: unknown) => { - if (input.sessionID() !== id) return - if (!shouldApplyExecutionResult({ requested: scope, current: input.executionScope() })) return - console.debug("[session-review] failed to fetch aggregate diff", { sessionID: id, scope, error }) - setSessionAggregateDiffs(undefined) - }) - }) - return { changes, setChanges, diff --git a/packages/app/src/pages/session/use-session-vcs-refresh.test.ts b/packages/app/src/pages/session/use-session-vcs-refresh.test.ts index bbae50d1a..90d3372b9 100644 --- a/packages/app/src/pages/session/use-session-vcs-refresh.test.ts +++ b/packages/app/src/pages/session/use-session-vcs-refresh.test.ts @@ -2,20 +2,45 @@ import { describe, expect, test } from "bun:test" import { isFileWatcherVcsRefreshEvent } from "./use-session-vcs-refresh" describe("session vcs refresh watcher events", () => { - test("refreshes for rescan and non-git file updates only", () => { + test("refreshes for rescan, source updates, and git state updates", () => { expect(isFileWatcherVcsRefreshEvent({ type: "file.watcher.rescan", properties: { directory: "/repo" } })).toBe(true) - expect( - isFileWatcherVcsRefreshEvent({ - type: "file.watcher.updated", - properties: { file: "src/app.ts", event: "change" }, - }), - ).toBe(true) - expect( - isFileWatcherVcsRefreshEvent({ - type: "file.watcher.updated", - properties: { file: ".git/index", event: "change" }, - }), - ).toBe(false) + + for (const file of [ + "src/app.ts", + ".git/index", + ".git/HEAD", + ".git/packed-refs", + ".git/refs/heads/feature/test", + ".git/refs/remotes/origin/dev", + ".git/logs/HEAD", + ".git/worktrees/review-worktree/gitdir", + ".git\\refs\\heads\\feature\\test", + "/repo/.git/index", + "/repo/.git/HEAD", + "C:\\repo\\.git\\refs\\heads\\feature\\test", + ]) { + expect(isFileWatcherVcsRefreshEvent({ type: "file.watcher.updated", properties: { file, event: "change" } })).toBe( + true, + ) + } + + for (const file of [ + ".git/objects/aa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + ".git/refs/tags/v1.0.0", + ".git/refs/stash", + ".git/FETCH_HEAD", + ".git/MERGE_HEAD", + ".git/REVERT_HEAD", + ".git/CHERRY_PICK_HEAD", + "/repo/.git/objects/aa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "/repo/.git/refs/tags/v1.0.0", + "C:\\repo\\.git\\objects\\aa\\bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + ]) { + expect(isFileWatcherVcsRefreshEvent({ type: "file.watcher.updated", properties: { file, event: "change" } })).toBe( + false, + ) + } + expect(isFileWatcherVcsRefreshEvent({ type: "session.updated", properties: {} })).toBe(false) }) }) diff --git a/packages/app/src/pages/session/use-session-vcs-refresh.ts b/packages/app/src/pages/session/use-session-vcs-refresh.ts index cace405a3..e192217c2 100644 --- a/packages/app/src/pages/session/use-session-vcs-refresh.ts +++ b/packages/app/src/pages/session/use-session-vcs-refresh.ts @@ -55,6 +55,24 @@ export function isFileWatcherVcsRefreshEvent(event: { type: string; properties?: if (event.type !== "file.watcher.updated") return false const props = typeof event.properties === "object" && event.properties ? (event.properties as Record) : undefined - const file = typeof props?.file === "string" ? props.file : undefined - return !!file && !file.startsWith(".git/") + const file = normalizeWatcherFilePath(typeof props?.file === "string" ? props.file : undefined) + if (!file) return false + if (!file.startsWith(".git/")) return true + return ( + file === ".git/index" || + file === ".git/HEAD" || + file === ".git/packed-refs" || + file.startsWith(".git/refs/heads/") || + file.startsWith(".git/refs/remotes/") || + file.startsWith(".git/logs/HEAD") || + file.startsWith(".git/worktrees/") + ) +} + +function normalizeWatcherFilePath(file: string | undefined) { + const normalized = file?.replaceAll("\\", "/") + if (!normalized) return + const gitSegment = normalized.indexOf("/.git/") + if (gitSegment === -1) return normalized + return normalized.slice(gitSegment + 1) } diff --git a/packages/opencode/src/file/watcher.ts b/packages/opencode/src/file/watcher.ts index 88d6c7ae3..98e0ac14f 100644 --- a/packages/opencode/src/file/watcher.ts +++ b/packages/opencode/src/file/watcher.ts @@ -23,6 +23,9 @@ export namespace FileWatcher { const log = Log.create({ service: "file.watcher" }) const SUBSCRIBE_TIMEOUT_MS = 10_000 const RESCAN_DEDUPE_MS = 1_000 + const VCS_SUBSCRIBE_ENTRIES = new Set(["HEAD", "index", "packed-refs", "refs"]) + const VCS_REFRESH_FILES = new Set(["HEAD", "index", "packed-refs"]) + const VCS_REFRESH_PREFIXES = ["refs/heads/", "refs/remotes/"] export const Event = { Updated: BusEvent.define( @@ -124,6 +127,17 @@ export namespace FileWatcher { } } + export function vcsWatcherIgnoreEntries(entries: string[]) { + return entries.filter((entry) => !VCS_SUBSCRIBE_ENTRIES.has(entry)) + } + + export function shouldPublishVcsWatcherPath(file: string, vcsDir: string) { + const relative = path.relative(vcsDir, file).replaceAll(path.sep, "/") + if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return false + if (VCS_REFRESH_FILES.has(relative)) return true + return VCS_REFRESH_PREFIXES.some((prefix) => relative.startsWith(prefix)) + } + export interface Interface { readonly init: () => Effect.Effect } @@ -172,7 +186,9 @@ export namespace FileWatcher { }, }) yield* Effect.addFinalizer(() => Effect.sync(() => requestRescan.dispose())) - const createCallback = (dir: string): ParcelWatcher.SubscribeCallback => (err, evts) => + const createCallback = + (dir: string, shouldPublish = (_file: string) => true): ParcelWatcher.SubscribeCallback => + (err, evts) => Instance.restore(ctx, () => { if (err) { if (isDroppedEventsError(err)) { @@ -183,14 +199,15 @@ export namespace FileWatcher { return } for (const evt of evts) { + if (!shouldPublish(evt.path)) continue if (evt.type === "create") Bus.publish(Event.Updated, { file: evt.path, event: "add" }) if (evt.type === "update") Bus.publish(Event.Updated, { file: evt.path, event: "change" }) if (evt.type === "delete") Bus.publish(Event.Updated, { file: evt.path, event: "unlink" }) } }) - const subscribe = (dir: string, ignore: string[]) => { - const pending = w.subscribe(dir, createCallback(dir), { ignore, backend }) + const subscribe = (dir: string, ignore: string[], shouldPublish?: (file: string) => boolean) => { + const pending = w.subscribe(dir, createCallback(dir, shouldPublish), { ignore, backend }) return Effect.gen(function* () { const sub = yield* Effect.promise(() => pending) subs.push(sub) @@ -222,10 +239,8 @@ export namespace FileWatcher { const vcsDir = result.exitCode === 0 ? path.resolve(ctx.project.worktree, result.text().trim()) : undefined if (vcsDir && !cfgIgnores.includes(".git") && !cfgIgnores.includes(vcsDir)) { - const ignore = (yield* Effect.promise(() => readdir(vcsDir).catch(() => []))).filter( - (entry) => entry !== "HEAD", - ) - yield* subscribe(vcsDir, ignore) + const ignore = vcsWatcherIgnoreEntries(yield* Effect.promise(() => readdir(vcsDir).catch(() => []))) + yield* subscribe(vcsDir, ignore, (file) => shouldPublishVcsWatcherPath(file, vcsDir)) } } }, diff --git a/packages/opencode/src/project/instance-store.ts b/packages/opencode/src/project/instance-store.ts index 51e1b6cb8..ffc662fa9 100644 --- a/packages/opencode/src/project/instance-store.ts +++ b/packages/opencode/src/project/instance-store.ts @@ -15,6 +15,8 @@ import { withLifecycleCloseAction, } from "@/session/lifecycle-provenance" import { currentRequestContext } from "@/server/request-context" +import fs from "node:fs" +import path from "node:path" export interface LoadInput { directory: string @@ -26,6 +28,7 @@ type ContextMismatchReason = | "worktree_mismatch" | "project_id_mismatch" | "project_row_missing" + | "project_vcs_changed" | "explicit_context_changed" | "unknown_context_mismatch" @@ -70,6 +73,16 @@ function contextMismatchReason(ctx: InstanceContext, input: LoadInput): ContextM return undefined } +function hasGitMarker(directory: string) { + let current = directory + while (true) { + if (fs.existsSync(path.join(current, ".git"))) return true + const parent = path.dirname(current) + if (parent === current) return false + current = parent + } +} + export const layer = Layer.effect( Service, Effect.gen(function* () { @@ -211,8 +224,20 @@ export const layer = Layer.effect( const mismatchReason = contextMismatchReason(exit.value, input) if (!mismatchReason) { const row = yield* project.get(exit.value.project.id) - if (row) return exit.value - return yield* reload(input, "project_row_missing") + if (!row) return yield* reload(input, "project_row_missing") + if (exit.value.project.vcs !== "git" && hasGitMarker(directory)) { + const next = yield* project.fromDirectory(directory) + if (next.project.vcs === "git") + return yield* reload( + { + directory, + worktree: next.sandbox, + project: next.project, + }, + "project_vcs_changed", + ) + } + return exit.value } return yield* reload(input, mismatchReason) } diff --git a/packages/opencode/test/file/watcher.test.ts b/packages/opencode/test/file/watcher.test.ts index 0c8968d94..4c410e233 100644 --- a/packages/opencode/test/file/watcher.test.ts +++ b/packages/opencode/test/file/watcher.test.ts @@ -145,6 +145,31 @@ function ready(directory: string) { // Tests // --------------------------------------------------------------------------- +describe("FileWatcher git metadata filtering", () => { + test("keeps review-diff git metadata subscribed", () => { + expect( + FileWatcher.vcsWatcherIgnoreEntries(["HEAD", "index", "packed-refs", "refs", "objects", "logs", "hooks"]), + ).toEqual(["objects", "logs", "hooks"]) + }) + + test("publishes only review-diff git metadata from the vcs directory", () => { + const gitDir = path.join("/tmp", "repo", ".git") + + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "HEAD"), gitDir)).toBe(true) + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "index"), gitDir)).toBe(true) + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "packed-refs"), gitDir)).toBe(true) + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "refs", "heads", "feature"), gitDir)).toBe(true) + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "refs", "remotes", "origin", "dev"), gitDir)).toBe( + true, + ) + + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "objects", "ab", "hash"), gitDir)).toBe(false) + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "refs", "tags", "v1"), gitDir)).toBe(false) + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "refs", "stash"), gitDir)).toBe(false) + expect(FileWatcher.shouldPublishVcsWatcherPath(path.join(gitDir, "MERGE_HEAD"), gitDir)).toBe(false) + }) +}) + describeWatcher("FileWatcher", () => { afterEach(async () => { await Instance.disposeAll() @@ -206,21 +231,50 @@ describeWatcher("FileWatcher", () => { }) }) - test("ignores .git/index changes", async () => { + test("publishes .git/index changes", async () => { await using tmp = await tmpdir({ git: true }) const gitIndex = path.join(tmp.path, ".git", "index") const edit = path.join(tmp.path, "tracked.txt") await withWatcher( tmp.path, - noUpdate( + nextUpdate( tmp.path, (e) => e.file === gitIndex, Effect.promise(async () => { await fs.writeFile(edit, "a") await $`git add .`.cwd(tmp.path).quiet().nothrow() }), - ), + ).pipe(Effect.tap((evt) => Effect.sync(() => expect(evt.event).not.toBe("unlink")))), + ) + }) + + test("publishes .git refs/heads changes", async () => { + await using tmp = await tmpdir({ git: true }) + const branchRef = path.join(tmp.path, ".git", "refs", "heads", "watch-ref") + const hash = await $`git rev-parse HEAD`.cwd(tmp.path).quiet().text() + + await withWatcher( + tmp.path, + nextUpdate( + tmp.path, + (evt) => evt.file === branchRef && evt.event !== "unlink", + Effect.promise(() => fs.writeFile(branchRef, hash.trim() + "\n")), + ).pipe(Effect.tap((evt) => Effect.sync(() => expect(["add", "change"]).toContain(evt.event)))), + ) + }) + + test("publishes .git/packed-refs changes", async () => { + await using tmp = await tmpdir({ git: true }) + const packedRefs = path.join(tmp.path, ".git", "packed-refs") + + await withWatcher( + tmp.path, + nextUpdate( + tmp.path, + (evt) => evt.file === packedRefs && evt.event !== "unlink", + Effect.promise(() => fs.writeFile(packedRefs, "# pack-refs with: peeled fully-peeled sorted\n")), + ).pipe(Effect.tap((evt) => Effect.sync(() => expect(["add", "change"]).toContain(evt.event)))), ) }) diff --git a/packages/opencode/test/project/instance-store.test.ts b/packages/opencode/test/project/instance-store.test.ts index 8dbe72167..95a9da5c7 100644 --- a/packages/opencode/test/project/instance-store.test.ts +++ b/packages/opencode/test/project/instance-store.test.ts @@ -1,4 +1,5 @@ import { afterEach, describe, expect, test } from "bun:test" +import { $ } from "bun" import { Effect, Exit, Fiber, Layer, ManagedRuntime } from "effect" import * as CrossSpawnSpawner from "@opencode-ai/core/cross-spawn-spawner" @@ -140,6 +141,29 @@ describe("InstanceStore", () => { }), ) + it.live("reloads a cached non-git instance when the directory becomes git", () => + Effect.gen(function* () { + const dir = yield* tmpdirScoped() + const store = yield* InstanceStore.Service + const disposed: string[] = [] + const off = registerDisposer(async (directory) => { + disposed.push(directory) + }) + yield* Effect.addFinalizer(() => Effect.sync(off)) + + const first = yield* store.load({ directory: dir }) + expect(first.project.vcs).toBeUndefined() + + yield* Effect.promise(() => $`git init --quiet`.cwd(dir).quiet()) + + const second = yield* store.load({ directory: dir }) + expect(second).not.toBe(first) + expect(second.project.vcs).toBe("git") + expect(second.worktree).toBe(dir) + expect(disposed).toEqual([dir]) + }), + ) + it.live("disposeDirectory disposes loaded entries without loading missing directories", () => Effect.gen(function* () { const loaded = yield* tmpdirScoped()