From 324a39833d57ec87cd186c8e86c219acaa37b3ed Mon Sep 17 00:00:00 2001 From: Shoubhit Dash Date: Tue, 24 Mar 2026 13:43:40 +0530 Subject: [PATCH 01/13] core: refactor git utilities from util/git.ts to dedicated Git service module with proper Effect patterns --- packages/opencode/src/cli/cmd/github.ts | 10 +- packages/opencode/src/cli/cmd/pr.ts | 8 +- packages/opencode/src/file/index.ts | 14 +- packages/opencode/src/file/watcher.ts | 4 +- packages/opencode/src/git/index.ts | 317 ++++++++++++++++++ packages/opencode/src/project/project.ts | 10 +- packages/opencode/src/storage/storage.ts | 4 +- packages/opencode/src/util/git.ts | 35 -- packages/opencode/src/worktree/index.ts | 44 +-- .../opencode/test/project/project.test.ts | 73 ++-- 10 files changed, 402 insertions(+), 117 deletions(-) create mode 100644 packages/opencode/src/git/index.ts delete mode 100644 packages/opencode/src/util/git.ts diff --git a/packages/opencode/src/cli/cmd/github.ts b/packages/opencode/src/cli/cmd/github.ts index edd9d7561094..31ad65c07bbf 100644 --- a/packages/opencode/src/cli/cmd/github.ts +++ b/packages/opencode/src/cli/cmd/github.ts @@ -28,9 +28,9 @@ import { Provider } from "../../provider/provider" import { Bus } from "../../bus" import { MessageV2 } from "../../session/message-v2" import { SessionPrompt } from "@/session/prompt" +import { Git } from "@/git" import { setTimeout as sleep } from "node:timers/promises" import { Process } from "@/util/process" -import { git } from "@/util/git" type GitHubAuthor = { login: string @@ -257,7 +257,7 @@ export const GithubInstallCommand = cmd({ } // Get repo info - const info = (await git(["remote", "get-url", "origin"], { cwd: Instance.worktree })).text().trim() + const info = (await Git.run(["remote", "get-url", "origin"], { cwd: Instance.worktree })).text().trim() const parsed = parseGitHubRemote(info) if (!parsed) { prompts.log.error(`Could not find git repository. Please run this command from a git repository.`) @@ -496,20 +496,20 @@ export const GithubRunCommand = cmd({ : "issue" : undefined const gitText = async (args: string[]) => { - const result = await git(args, { cwd: Instance.worktree }) + const result = await Git.run(args, { cwd: Instance.worktree }) if (result.exitCode !== 0) { throw new Process.RunFailedError(["git", ...args], result.exitCode, result.stdout, result.stderr) } return result.text().trim() } const gitRun = async (args: string[]) => { - const result = await git(args, { cwd: Instance.worktree }) + const result = await Git.run(args, { cwd: Instance.worktree }) if (result.exitCode !== 0) { throw new Process.RunFailedError(["git", ...args], result.exitCode, result.stdout, result.stderr) } return result } - const gitStatus = (args: string[]) => git(args, { cwd: Instance.worktree }) + const gitStatus = (args: string[]) => Git.run(args, { cwd: Instance.worktree }) const commitChanges = async (summary: string, actor?: string) => { const args = ["commit", "-m", summary] if (actor) args.push("-m", `Co-authored-by: ${actor} <${actor}@users.noreply.github.com>`) diff --git a/packages/opencode/src/cli/cmd/pr.ts b/packages/opencode/src/cli/cmd/pr.ts index 8826fe343ea0..58d42c6ef075 100644 --- a/packages/opencode/src/cli/cmd/pr.ts +++ b/packages/opencode/src/cli/cmd/pr.ts @@ -1,8 +1,8 @@ import { UI } from "../ui" import { cmd } from "./cmd" +import { Git } from "@/git" import { Instance } from "@/project/instance" import { Process } from "@/util/process" -import { git } from "@/util/git" export const PrCommand = cmd({ command: "pr ", @@ -67,9 +67,9 @@ export const PrCommand = cmd({ const remoteName = forkOwner // Check if remote already exists - const remotes = (await git(["remote"], { cwd: Instance.worktree })).text().trim() + const remotes = (await Git.run(["remote"], { cwd: Instance.worktree })).text().trim() if (!remotes.split("\n").includes(remoteName)) { - await git(["remote", "add", remoteName, `https://github.com/${forkOwner}/${forkName}.git`], { + await Git.run(["remote", "add", remoteName, `https://github.com/${forkOwner}/${forkName}.git`], { cwd: Instance.worktree, }) UI.println(`Added fork remote: ${remoteName}`) @@ -77,7 +77,7 @@ export const PrCommand = cmd({ // Set upstream to the fork so pushes go there const headRefName = prInfo.headRefName - await git(["branch", `--set-upstream-to=${remoteName}/${headRefName}`, localBranchName], { + await Git.run(["branch", `--set-upstream-to=${remoteName}/${headRefName}`, localBranchName], { cwd: Instance.worktree, }) } diff --git a/packages/opencode/src/file/index.ts b/packages/opencode/src/file/index.ts index 23c77e7bf713..7dc36e9c3da5 100644 --- a/packages/opencode/src/file/index.ts +++ b/packages/opencode/src/file/index.ts @@ -1,7 +1,7 @@ import { BusEvent } from "@/bus/bus-event" import { InstanceState } from "@/effect/instance-state" import { makeRunPromise } from "@/effect/run-service" -import { git } from "@/util/git" +import { Git } from "@/git" import { Effect, Fiber, Layer, Scope, ServiceMap } from "effect" import { formatPatch, structuredPatch } from "diff" import fs from "fs" @@ -432,7 +432,7 @@ export namespace File { return yield* Effect.promise(async () => { const diffOutput = ( - await git(["-c", "core.fsmonitor=false", "-c", "core.quotepath=false", "diff", "--numstat", "HEAD"], { + await Git.run(["-c", "core.fsmonitor=false", "-c", "core.quotepath=false", "diff", "--numstat", "HEAD"], { cwd: Instance.directory, }) ).text() @@ -452,7 +452,7 @@ export namespace File { } const untrackedOutput = ( - await git( + await Git.run( [ "-c", "core.fsmonitor=false", @@ -485,7 +485,7 @@ export namespace File { } const deletedOutput = ( - await git( + await Git.run( [ "-c", "core.fsmonitor=false", @@ -576,17 +576,17 @@ export namespace File { if (Instance.project.vcs === "git") { let diff = ( - await git(["-c", "core.fsmonitor=false", "diff", "--", file], { cwd: Instance.directory }) + await Git.run(["-c", "core.fsmonitor=false", "diff", "--", file], { cwd: Instance.directory }) ).text() if (!diff.trim()) { diff = ( - await git(["-c", "core.fsmonitor=false", "diff", "--staged", "--", file], { + await Git.run(["-c", "core.fsmonitor=false", "diff", "--staged", "--", file], { cwd: Instance.directory, }) ).text() } if (diff.trim()) { - const original = (await git(["show", `HEAD:${file}`], { cwd: Instance.directory })).text() + const original = (await Git.run(["show", `HEAD:${file}`], { cwd: Instance.directory })).text() const patch = structuredPatch(file, file, original, content, "old", "new", { context: Infinity, ignoreWhitespace: true, diff --git a/packages/opencode/src/file/watcher.ts b/packages/opencode/src/file/watcher.ts index 1b3fc8ab4f2d..ba70791433da 100644 --- a/packages/opencode/src/file/watcher.ts +++ b/packages/opencode/src/file/watcher.ts @@ -10,8 +10,8 @@ import { BusEvent } from "@/bus/bus-event" import { InstanceState } from "@/effect/instance-state" import { makeRunPromise } from "@/effect/run-service" import { Flag } from "@/flag/flag" +import { Git } from "@/git" import { Instance } from "@/project/instance" -import { git } from "@/util/git" import { lazy } from "@/util/lazy" import { Config } from "../config/config" import { FileIgnore } from "./ignore" @@ -130,7 +130,7 @@ export namespace FileWatcher { if (Instance.project.vcs === "git") { const result = yield* Effect.promise(() => - git(["rev-parse", "--git-dir"], { + Git.run(["rev-parse", "--git-dir"], { cwd: Instance.project.worktree, }), ) diff --git a/packages/opencode/src/git/index.ts b/packages/opencode/src/git/index.ts new file mode 100644 index 000000000000..d7e6d3ac1465 --- /dev/null +++ b/packages/opencode/src/git/index.ts @@ -0,0 +1,317 @@ +import { NodeChildProcessSpawner, NodeFileSystem, NodePath } from "@effect/platform-node" +import { Effect, Layer, ServiceMap, Stream } from "effect" +import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process" +import { makeRunPromise } from "@/effect/run-service" + +export namespace Git { + const cfg = [ + "--no-optional-locks", + "-c", + "core.autocrlf=false", + "-c", + "core.fsmonitor=false", + "-c", + "core.longpaths=true", + "-c", + "core.symlinks=true", + "-c", + "core.quotepath=false", + ] as const + + const out = (result: { text(): string }) => result.text().trim() + const split = (text: string) => text.split("\0").filter(Boolean) + const fail = (err: unknown) => + ({ + exitCode: 1, + text: () => "", + stdout: Buffer.alloc(0), + stderr: Buffer.from(err instanceof Error ? err.message : String(err)), + }) satisfies Result + + export type Kind = "added" | "deleted" | "modified" + + export type Base = { + readonly name: string + readonly ref: string + } + + export type Item = { + readonly file: string + readonly code: string + readonly status: Kind + } + + export type Stat = { + readonly file: string + readonly additions: number + readonly deletions: number + } + + export interface Result { + readonly exitCode: number + readonly text: () => string + readonly stdout: Buffer + readonly stderr: Buffer + } + + export interface Options { + readonly cwd: string + readonly env?: Record + } + + export interface Interface { + readonly run: (args: string[], opts: Options) => Effect.Effect + readonly branch: (cwd: string) => Effect.Effect + readonly prefix: (cwd: string) => Effect.Effect + readonly defaultBranch: (cwd: string) => Effect.Effect + readonly hasHead: (cwd: string) => Effect.Effect + readonly mergeBase: (cwd: string, base: string, head?: string) => Effect.Effect + readonly show: (cwd: string, ref: string, file: string, prefix?: string) => Effect.Effect + readonly status: (cwd: string) => Effect.Effect + readonly diff: (cwd: string, ref: string) => Effect.Effect + readonly stats: (cwd: string, ref: string) => Effect.Effect + } + + const kind = (code?: string): Kind => { + if (code === "??") return "added" + if (code?.includes("U")) return "modified" + if (code?.includes("A") && !code.includes("D")) return "added" + if (code?.includes("D") && !code.includes("A")) return "deleted" + return "modified" + } + + const parseStatus = (text: string) => + split(text).flatMap((item) => { + const file = item.slice(3) + if (!file) return [] + const code = item.slice(0, 2) + return [{ file, code, status: kind(code) } satisfies Item] + }) + + const parseNames = (text: string) => { + const list = split(text) + return list.flatMap((code, idx) => { + if (idx % 2 !== 0) return [] + const file = list[idx + 1] + if (!code || !file) return [] + return [{ file, code, status: kind(code) } satisfies Item] + }) + } + + const parseStats = (text: string) => + split(text).flatMap((item) => { + const a = item.indexOf("\t") + const b = item.indexOf("\t", a + 1) + if (a === -1 || b === -1) return [] + const file = item.slice(b + 1) + if (!file) return [] + const adds = item.slice(0, a) + const dels = item.slice(a + 1, b) + const additions = adds === "-" ? 0 : Number.parseInt(adds || "0", 10) + const deletions = dels === "-" ? 0 : Number.parseInt(dels || "0", 10) + return [ + { + file, + additions: Number.isFinite(additions) ? additions : 0, + deletions: Number.isFinite(deletions) ? deletions : 0, + } satisfies Stat, + ] + }) + + export class Service extends ServiceMap.Service()("@opencode/Git") {} + + export const layer = Layer.effect( + Service, + Effect.gen(function* () { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner + + const run = Effect.fn("Git.run")( + function* (args: string[], opts: Options) { + const proc = ChildProcess.make("git", [...cfg, ...args], { + cwd: opts.cwd, + env: opts.env, + extendEnv: true, + stdin: "ignore", + stdout: "pipe", + stderr: "pipe", + }) + const handle = yield* spawner.spawn(proc) + const [stdout, stderr] = yield* Effect.all( + [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))], + { concurrency: 2 }, + ) + return { + exitCode: yield* handle.exitCode, + text: () => stdout, + stdout: Buffer.from(stdout), + stderr: Buffer.from(stderr), + } satisfies Result + }, + Effect.scoped, + Effect.catch((err) => Effect.succeed(fail(err))), + ) + + const text = Effect.fn("Git.text")(function* (args: string[], opts: Options) { + return (yield* run(args, opts)).text() + }) + + const lines = Effect.fn("Git.lines")(function* (args: string[], opts: Options) { + return (yield* text(args, opts)) + .split(/\r?\n/) + .map((item) => item.trim()) + .filter(Boolean) + }) + + const refs = Effect.fnUntraced(function* (cwd: string) { + return yield* lines(["for-each-ref", "--format=%(refname:short)", "refs/heads"], { cwd }) + }) + + const configured = Effect.fnUntraced(function* (cwd: string, list: string[]) { + const result = yield* run(["config", "init.defaultBranch"], { cwd }) + const name = out(result) + if (!name || !list.includes(name)) return + return { name, ref: name } satisfies Base + }) + + const primary = Effect.fnUntraced(function* (cwd: string) { + const list = yield* lines(["remote"], { cwd }) + if (list.includes("origin")) return "origin" + if (list.length === 1) return list[0] + if (list.includes("upstream")) return "upstream" + return list[0] + }) + + const branch = Effect.fn("Git.branch")(function* (cwd: string) { + const result = yield* run(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd }) + if (result.exitCode !== 0) return + const text = out(result) + return text || undefined + }) + + const prefix = Effect.fn("Git.prefix")(function* (cwd: string) { + const result = yield* run(["rev-parse", "--show-prefix"], { cwd }) + if (result.exitCode !== 0) return "" + return out(result) + }) + + const defaultBranch = Effect.fn("Git.defaultBranch")(function* (cwd: string) { + const remote = yield* primary(cwd) + if (remote) { + const head = yield* run(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd }) + if (head.exitCode === 0) { + const ref = out(head).replace(/^refs\/remotes\//, "") + const name = ref.startsWith(`${remote}/`) ? ref.slice(`${remote}/`.length) : "" + if (name) return { name, ref } satisfies Base + } + } + + const list = yield* refs(cwd) + const next = yield* configured(cwd, list) + if (next) return next + if (list.includes("main")) return { name: "main", ref: "main" } satisfies Base + if (list.includes("master")) return { name: "master", ref: "master" } satisfies Base + }) + + const hasHead = Effect.fn("Git.hasHead")(function* (cwd: string) { + const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd }) + return result.exitCode === 0 + }) + + const mergeBase = Effect.fn("Git.mergeBase")(function* (cwd: string, base: string, head = "HEAD") { + const result = yield* run(["merge-base", base, head], { cwd }) + if (result.exitCode !== 0) return + const text = out(result) + return text || undefined + }) + + const show = Effect.fn("Git.show")(function* (cwd: string, ref: string, file: string, prefix = "") { + const target = prefix ? `${prefix}${file}` : file + const result = yield* run(["show", `${ref}:${target}`], { cwd }) + if (result.exitCode !== 0) return "" + if (result.stdout.includes(0)) return "" + return result.text() + }) + + const status = Effect.fn("Git.status")(function* (cwd: string) { + return parseStatus( + yield* text(["status", "--porcelain=v1", "--untracked-files=all", "--no-renames", "-z", "--", "."], { + cwd, + }), + ) + }) + + const diff = Effect.fn("Git.diff")(function* (cwd: string, ref: string) { + return parseNames( + yield* text(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, "--", "."], { cwd }), + ) + }) + + const stats = Effect.fn("Git.stats")(function* (cwd: string, ref: string) { + return parseStats( + yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, "--", "."], { cwd }), + ) + }) + + return Service.of({ + run, + branch, + prefix, + defaultBranch, + hasHead, + mergeBase, + show, + status, + diff, + stats, + }) + }), + ) + + export const defaultLayer = layer.pipe( + Layer.provide(NodeChildProcessSpawner.layer), + Layer.provide(NodeFileSystem.layer), + Layer.provide(NodePath.layer), + ) + + const runPromise = makeRunPromise(Service, defaultLayer) + + export function run(args: string[], opts: Options) { + return runPromise((git) => git.run(args, opts)) + } + + export function branch(cwd: string) { + return runPromise((git) => git.branch(cwd)) + } + + export function prefix(cwd: string) { + return runPromise((git) => git.prefix(cwd)) + } + + export function defaultBranch(cwd: string) { + return runPromise((git) => git.defaultBranch(cwd)) + } + + export function hasHead(cwd: string) { + return runPromise((git) => git.hasHead(cwd)) + } + + export function mergeBase(cwd: string, base: string, head?: string) { + return runPromise((git) => git.mergeBase(cwd, base, head)) + } + + export function show(cwd: string, ref: string, file: string, prefix?: string) { + return runPromise((git) => git.show(cwd, ref, file, prefix)) + } + + export function status(cwd: string) { + return runPromise((git) => git.status(cwd)) + } + + export function diff(cwd: string, ref: string) { + return runPromise((git) => git.diff(cwd, ref)) + } + + export function stats(cwd: string, ref: string) { + return runPromise((git) => git.stats(cwd, ref)) + } +} diff --git a/packages/opencode/src/project/project.ts b/packages/opencode/src/project/project.ts index 1cef41c85c91..4894fea1b928 100644 --- a/packages/opencode/src/project/project.ts +++ b/packages/opencode/src/project/project.ts @@ -10,8 +10,8 @@ import { fn } from "@opencode-ai/util/fn" import { BusEvent } from "@/bus/bus-event" import { iife } from "@/util/iife" import { GlobalBus } from "@/bus/global" +import { Git } from "@/git" import { existsSync } from "fs" -import { git } from "../util/git" import { Glob } from "../util/glob" import { which } from "../util/which" import { ProjectID } from "./schema" @@ -119,7 +119,7 @@ export namespace Project { } } - const worktree = await git(["rev-parse", "--git-common-dir"], { + const worktree = await Git.run(["rev-parse", "--git-common-dir"], { cwd: sandbox, }) .then(async (result) => { @@ -147,7 +147,7 @@ export namespace Project { // generate id from root commit if (!id) { - const roots = await git(["rev-list", "--max-parents=0", "HEAD"], { + const roots = await Git.run(["rev-list", "--max-parents=0", "HEAD"], { cwd: sandbox, }) .then(async (result) => @@ -184,7 +184,7 @@ export namespace Project { } } - const top = await git(["rev-parse", "--show-toplevel"], { + const top = await Git.run(["rev-parse", "--show-toplevel"], { cwd: sandbox, }) .then(async (result) => gitpath(sandbox, await result.text())) @@ -349,7 +349,7 @@ export namespace Project { if (input.project.vcs === "git") return input.project if (!which("git")) throw new Error("Git is not installed") - const result = await git(["init", "--quiet"], { + const result = await Git.run(["init", "--quiet"], { cwd: input.directory, }) if (result.exitCode !== 0) { diff --git a/packages/opencode/src/storage/storage.ts b/packages/opencode/src/storage/storage.ts index a78607cdfd57..e48bfc1b6786 100644 --- a/packages/opencode/src/storage/storage.ts +++ b/packages/opencode/src/storage/storage.ts @@ -7,8 +7,8 @@ import { lazy } from "../util/lazy" import { Lock } from "../util/lock" import { NamedError } from "@opencode-ai/util/error" import z from "zod" +import { Git } from "@/git" import { Glob } from "../util/glob" -import { git } from "@/util/git" export namespace Storage { const log = Log.create({ service: "storage" }) @@ -49,7 +49,7 @@ export namespace Storage { } if (!worktree) continue if (!(await Filesystem.isDir(worktree))) continue - const result = await git(["rev-list", "--max-parents=0", "--all"], { + const result = await Git.run(["rev-list", "--max-parents=0", "--all"], { cwd: worktree, }) const [id] = result diff --git a/packages/opencode/src/util/git.ts b/packages/opencode/src/util/git.ts deleted file mode 100644 index 731131357f21..000000000000 --- a/packages/opencode/src/util/git.ts +++ /dev/null @@ -1,35 +0,0 @@ -import { Process } from "./process" - -export interface GitResult { - exitCode: number - text(): string - stdout: Buffer - stderr: Buffer -} - -/** - * Run a git command. - * - * Uses Process helpers with stdin ignored to avoid protocol pipe inheritance - * issues in embedded/client environments. - */ -export async function git(args: string[], opts: { cwd: string; env?: Record }): Promise { - return Process.run(["git", ...args], { - cwd: opts.cwd, - env: opts.env, - stdin: "ignore", - nothrow: true, - }) - .then((result) => ({ - exitCode: result.code, - text: () => result.stdout.toString(), - stdout: result.stdout, - stderr: result.stderr, - })) - .catch((error) => ({ - exitCode: 1, - text: () => "", - stdout: Buffer.alloc(0), - stderr: Buffer.from(error instanceof Error ? error.message : String(error)), - })) -} diff --git a/packages/opencode/src/worktree/index.ts b/packages/opencode/src/worktree/index.ts index 6ed0e4820241..10b455c48a7e 100644 --- a/packages/opencode/src/worktree/index.ts +++ b/packages/opencode/src/worktree/index.ts @@ -12,9 +12,9 @@ import type { ProjectID } from "../project/schema" import { fn } from "../util/fn" import { Log } from "../util/log" import { Process } from "../util/process" -import { git } from "../util/git" import { BusEvent } from "@/bus/bus-event" import { GlobalBus } from "@/bus/global" +import { Git } from "@/git" export namespace Worktree { const log = Log.create({ service: "worktree" }) @@ -250,14 +250,14 @@ export namespace Worktree { } async function sweep(root: string) { - const first = await git(["clean", "-ffdx"], { cwd: root }) + const first = await Git.run(["clean", "-ffdx"], { cwd: root }) if (first.exitCode === 0) return first const entries = failed(first) if (!entries.length) return first await prune(root, entries) - return git(["clean", "-ffdx"], { cwd: root }) + return Git.run(["clean", "-ffdx"], { cwd: root }) } async function canonical(input: string) { @@ -276,7 +276,7 @@ export namespace Worktree { if (await exists(directory)) continue const ref = `refs/heads/${branch}` - const branchCheck = await git(["show-ref", "--verify", "--quiet", ref], { + const branchCheck = await Git.run(["show-ref", "--verify", "--quiet", ref], { cwd: Instance.worktree, }) if (branchCheck.exitCode === 0) continue @@ -348,7 +348,7 @@ export namespace Worktree { } export async function createFromInfo(info: Info, startCommand?: string) { - const created = await git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], { + const created = await Git.run(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], { cwd: Instance.worktree, }) if (created.exitCode !== 0) { @@ -362,7 +362,7 @@ export namespace Worktree { return () => { const start = async () => { - const populated = await git(["reset", "--hard"], { cwd: info.directory }) + const populated = await Git.run(["reset", "--hard"], { cwd: info.directory }) if (populated.exitCode !== 0) { const message = errorText(populated) || "Failed to populate worktree" log.error("worktree checkout failed", { directory: info.directory, message }) @@ -479,10 +479,10 @@ export namespace Worktree { const stop = async (target: string) => { if (!(await exists(target))) return - await git(["fsmonitor--daemon", "stop"], { cwd: target }) + await Git.run(["fsmonitor--daemon", "stop"], { cwd: target }) } - const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree }) + const list = await Git.run(["worktree", "list", "--porcelain"], { cwd: Instance.worktree }) if (list.exitCode !== 0) { throw new RemoveFailedError({ message: errorText(list) || "Failed to read git worktrees" }) } @@ -499,11 +499,11 @@ export namespace Worktree { } await stop(entry.path) - const removed = await git(["worktree", "remove", "--force", entry.path], { + const removed = await Git.run(["worktree", "remove", "--force", entry.path], { cwd: Instance.worktree, }) if (removed.exitCode !== 0) { - const next = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree }) + const next = await Git.run(["worktree", "list", "--porcelain"], { cwd: Instance.worktree }) if (next.exitCode !== 0) { throw new RemoveFailedError({ message: errorText(removed) || errorText(next) || "Failed to remove git worktree", @@ -520,7 +520,7 @@ export namespace Worktree { const branch = entry.branch?.replace(/^refs\/heads\//, "") if (branch) { - const deleted = await git(["branch", "-D", branch], { cwd: Instance.worktree }) + const deleted = await Git.run(["branch", "-D", branch], { cwd: Instance.worktree }) if (deleted.exitCode !== 0) { throw new RemoveFailedError({ message: errorText(deleted) || "Failed to delete worktree branch" }) } @@ -540,7 +540,7 @@ export namespace Worktree { throw new ResetFailedError({ message: "Cannot reset the primary workspace" }) } - const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree }) + const list = await Git.run(["worktree", "list", "--porcelain"], { cwd: Instance.worktree }) if (list.exitCode !== 0) { throw new ResetFailedError({ message: errorText(list) || "Failed to read git worktrees" }) } @@ -573,7 +573,7 @@ export namespace Worktree { throw new ResetFailedError({ message: "Worktree not found" }) } - const remoteList = await git(["remote"], { cwd: Instance.worktree }) + const remoteList = await Git.run(["remote"], { cwd: Instance.worktree }) if (remoteList.exitCode !== 0) { throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" }) } @@ -592,17 +592,17 @@ export namespace Worktree { : "" const remoteHead = remote - ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree }) + ? await Git.run(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree }) : { exitCode: 1, stdout: undefined, stderr: undefined } const remoteRef = remoteHead.exitCode === 0 ? outputText(remoteHead.stdout) : "" const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : "" const remoteBranch = remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : "" - const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], { + const mainCheck = await Git.run(["show-ref", "--verify", "--quiet", "refs/heads/main"], { cwd: Instance.worktree, }) - const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], { + const masterCheck = await Git.run(["show-ref", "--verify", "--quiet", "refs/heads/master"], { cwd: Instance.worktree, }) const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : "" @@ -613,7 +613,7 @@ export namespace Worktree { } if (remoteBranch) { - const fetch = await git(["fetch", remote, remoteBranch], { cwd: Instance.worktree }) + const fetch = await Git.run(["fetch", remote, remoteBranch], { cwd: Instance.worktree }) if (fetch.exitCode !== 0) { throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` }) } @@ -625,7 +625,7 @@ export namespace Worktree { const worktreePath = entry.path - const resetToTarget = await git(["reset", "--hard", target], { cwd: worktreePath }) + const resetToTarget = await Git.run(["reset", "--hard", target], { cwd: worktreePath }) if (resetToTarget.exitCode !== 0) { throw new ResetFailedError({ message: errorText(resetToTarget) || "Failed to reset worktree to target" }) } @@ -635,26 +635,26 @@ export namespace Worktree { throw new ResetFailedError({ message: errorText(clean) || "Failed to clean worktree" }) } - const update = await git(["submodule", "update", "--init", "--recursive", "--force"], { cwd: worktreePath }) + const update = await Git.run(["submodule", "update", "--init", "--recursive", "--force"], { cwd: worktreePath }) if (update.exitCode !== 0) { throw new ResetFailedError({ message: errorText(update) || "Failed to update submodules" }) } - const subReset = await git(["submodule", "foreach", "--recursive", "git", "reset", "--hard"], { + const subReset = await Git.run(["submodule", "foreach", "--recursive", "git", "reset", "--hard"], { cwd: worktreePath, }) if (subReset.exitCode !== 0) { throw new ResetFailedError({ message: errorText(subReset) || "Failed to reset submodules" }) } - const subClean = await git(["submodule", "foreach", "--recursive", "git", "clean", "-fdx"], { + const subClean = await Git.run(["submodule", "foreach", "--recursive", "git", "clean", "-fdx"], { cwd: worktreePath, }) if (subClean.exitCode !== 0) { throw new ResetFailedError({ message: errorText(subClean) || "Failed to clean submodules" }) } - const status = await git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath }) + const status = await Git.run(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath }) if (status.exitCode !== 0) { throw new ResetFailedError({ message: errorText(status) || "Failed to read git status" }) } diff --git a/packages/opencode/test/project/project.test.ts b/packages/opencode/test/project/project.test.ts index a71fe0528f02..d13f424a8ffd 100644 --- a/packages/opencode/test/project/project.test.ts +++ b/packages/opencode/test/project/project.test.ts @@ -10,45 +10,48 @@ import { ProjectID } from "../../src/project/schema" Log.init({ print: false }) -const gitModule = await import("../../src/util/git") -const originalGit = gitModule.git +const gitModule = await import("../../src/git") +const originalRun = gitModule.Git.run type Mode = "none" | "rev-list-fail" | "top-fail" | "common-dir-fail" let mode: Mode = "none" -mock.module("../../src/util/git", () => ({ - git: (args: string[], opts: { cwd: string; env?: Record }) => { - const cmd = ["git", ...args].join(" ") - if ( - mode === "rev-list-fail" && - cmd.includes("git rev-list") && - cmd.includes("--max-parents=0") && - cmd.includes("HEAD") - ) { - return Promise.resolve({ - exitCode: 128, - text: () => Promise.resolve(""), - stdout: Buffer.from(""), - stderr: Buffer.from("fatal"), - }) - } - if (mode === "top-fail" && cmd.includes("git rev-parse") && cmd.includes("--show-toplevel")) { - return Promise.resolve({ - exitCode: 128, - text: () => Promise.resolve(""), - stdout: Buffer.from(""), - stderr: Buffer.from("fatal"), - }) - } - if (mode === "common-dir-fail" && cmd.includes("git rev-parse") && cmd.includes("--git-common-dir")) { - return Promise.resolve({ - exitCode: 128, - text: () => Promise.resolve(""), - stdout: Buffer.from(""), - stderr: Buffer.from("fatal"), - }) - } - return originalGit(args, opts) +mock.module("../../src/git", () => ({ + Git: { + ...gitModule.Git, + run: (args: string[], opts: { cwd: string; env?: Record }) => { + const cmd = ["git", ...args].join(" ") + if ( + mode === "rev-list-fail" && + cmd.includes("git rev-list") && + cmd.includes("--max-parents=0") && + cmd.includes("HEAD") + ) { + return Promise.resolve({ + exitCode: 128, + text: () => "", + stdout: Buffer.from(""), + stderr: Buffer.from("fatal"), + }) + } + if (mode === "top-fail" && cmd.includes("git rev-parse") && cmd.includes("--show-toplevel")) { + return Promise.resolve({ + exitCode: 128, + text: () => "", + stdout: Buffer.from(""), + stderr: Buffer.from("fatal"), + }) + } + if (mode === "common-dir-fail" && cmd.includes("git rev-parse") && cmd.includes("--git-common-dir")) { + return Promise.resolve({ + exitCode: 128, + text: () => "", + stdout: Buffer.from(""), + stderr: Buffer.from("fatal"), + }) + } + return originalRun(args, opts) + }, }, })) From 614ae4895e29d3b76fe8d32c9a9f588208017fd8 Mon Sep 17 00:00:00 2001 From: Shoubhit Dash Date: Tue, 24 Mar 2026 13:43:42 +0530 Subject: [PATCH 02/13] core: add VCS diff tracking with branch comparison and file statistics so agents can analyze changes against default branch --- packages/opencode/src/project/vcs.ts | 171 ++++++++++++++++++--- packages/opencode/test/git/git.test.ts | 128 +++++++++++++++ packages/opencode/test/project/vcs.test.ts | 112 +++++++++++++- 3 files changed, 386 insertions(+), 25 deletions(-) create mode 100644 packages/opencode/test/git/git.test.ts diff --git a/packages/opencode/src/project/vcs.ts b/packages/opencode/src/project/vcs.ts index dea25b91b43b..e3243ba8eb21 100644 --- a/packages/opencode/src/project/vcs.ts +++ b/packages/opencode/src/project/vcs.ts @@ -1,17 +1,111 @@ import { Effect, Layer, ServiceMap } from "effect" +import path from "path" import { Bus } from "@/bus" import { BusEvent } from "@/bus/bus-event" import { InstanceState } from "@/effect/instance-state" import { makeRunPromise } from "@/effect/run-service" +import { AppFileSystem } from "@/filesystem" import { FileWatcher } from "@/file/watcher" +import { Git } from "@/git" +import { Snapshot } from "@/snapshot" import { Log } from "@/util/log" -import { git } from "@/util/git" import { Instance } from "./instance" import z from "zod" export namespace Vcs { const log = Log.create({ service: "vcs" }) + const count = (text: string) => { + if (!text) return 0 + if (!text.endsWith("\n")) return text.split("\n").length + return text.slice(0, -1).split("\n").length + } + + const work = Effect.fnUntraced(function* (fs: AppFileSystem.Interface, cwd: string, file: string) { + const full = path.join(cwd, file) + if (!(yield* fs.exists(full).pipe(Effect.orDie))) return "" + const buf = yield* fs.readFile(full).pipe(Effect.catch(() => Effect.succeed(new Uint8Array()))) + if (Buffer.from(buf).includes(0)) return "" + return Buffer.from(buf).toString("utf8") + }) + + const nums = (list: Git.Stat[]) => + new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }] as const)) + + const merge = (...lists: Git.Item[][]) => { + const out = new Map() + lists.flat().forEach((item) => { + if (!out.has(item.file)) out.set(item.file, item) + }) + return [...out.values()] + } + + const files = Effect.fnUntraced(function* ( + fs: AppFileSystem.Interface, + git: Git.Interface, + cwd: string, + ref: string | undefined, + list: Git.Item[], + map: Map, + ) { + const base = ref ? yield* git.prefix(cwd) : "" + const next = yield* Effect.forEach( + list, + (item) => + Effect.gen(function* () { + const before = item.status === "added" || !ref ? "" : yield* git.show(cwd, ref, item.file, base) + const after = item.status === "deleted" ? "" : yield* work(fs, cwd, item.file) + const stat = map.get(item.file) + return { + file: item.file, + before, + after, + additions: stat?.additions ?? (item.status === "added" ? count(after) : 0), + deletions: stat?.deletions ?? (item.status === "deleted" ? count(before) : 0), + status: item.status, + } satisfies Snapshot.FileDiff + }), + { concurrency: 8 }, + ) + return next.toSorted((a, b) => a.file.localeCompare(b.file)) + }) + + const track = Effect.fnUntraced(function* ( + fs: AppFileSystem.Interface, + git: Git.Interface, + cwd: string, + ref: string | undefined, + ) { + if (!ref) return yield* files(fs, git, cwd, ref, yield* git.status(cwd), new Map()) + const [list, stats] = yield* Effect.all([git.status(cwd), git.stats(cwd, ref)], { concurrency: 2 }) + return yield* files(fs, git, cwd, ref, list, nums(stats)) + }) + + const compare = Effect.fnUntraced(function* ( + fs: AppFileSystem.Interface, + git: Git.Interface, + cwd: string, + ref: string, + ) { + const [list, stats, extra] = yield* Effect.all([git.diff(cwd, ref), git.stats(cwd, ref), git.status(cwd)], { + concurrency: 3, + }) + return yield* files( + fs, + git, + cwd, + ref, + merge( + list, + extra.filter((item) => item.code === "??"), + ), + nums(stats), + ) + }) + + export const Mode = z.enum(["git", "branch"]) + export type Mode = z.infer + export const Event = { BranchUpdated: BusEvent.define( "vcs.branch.updated", @@ -23,7 +117,8 @@ export namespace Vcs { export const Info = z .object({ - branch: z.string(), + branch: z.string().optional(), + default_branch: z.string().optional(), }) .meta({ ref: "VcsInfo", @@ -33,37 +128,35 @@ export namespace Vcs { export interface Interface { readonly init: () => Effect.Effect readonly branch: () => Effect.Effect + readonly defaultBranch: () => Effect.Effect + readonly diff: (mode: Mode) => Effect.Effect } interface State { current: string | undefined + root: Git.Base | undefined } export class Service extends ServiceMap.Service()("@opencode/Vcs") {} - export const layer = Layer.effect( + export const layer: Layer.Layer = Layer.effect( Service, Effect.gen(function* () { + const fs = yield* AppFileSystem.Service + const git = yield* Git.Service const state = yield* InstanceState.make( Effect.fn("Vcs.state")((ctx) => Effect.gen(function* () { if (ctx.project.vcs !== "git") { - return { current: undefined } + return { current: undefined, root: undefined } } - const getCurrentBranch = async () => { - const result = await git(["rev-parse", "--abbrev-ref", "HEAD"], { - cwd: ctx.worktree, - }) - if (result.exitCode !== 0) return undefined - const text = result.text().trim() - return text || undefined - } - - const value = { - current: yield* Effect.promise(() => getCurrentBranch()), - } - log.info("initialized", { branch: value.current }) + const get = () => Effect.runPromise(git.branch(ctx.directory)) + const [current, root] = yield* Effect.all([git.branch(ctx.directory), git.defaultBranch(ctx.directory)], { + concurrency: 2, + }) + const value = { current, root } + log.info("initialized", { branch: value.current, default_branch: value.root?.name }) yield* Effect.acquireRelease( Effect.sync(() => @@ -71,12 +164,11 @@ export namespace Vcs { FileWatcher.Event.Updated, Instance.bind(async (evt) => { if (!evt.properties.file.endsWith("HEAD")) return - const next = await getCurrentBranch() - if (next !== value.current) { - log.info("branch changed", { from: value.current, to: next }) - value.current = next - Bus.publish(Event.BranchUpdated, { branch: next }) - } + const next = await get() + if (next === value.current) return + log.info("branch changed", { from: value.current, to: next }) + value.current = next + Bus.publish(Event.BranchUpdated, { branch: next }) }), ), ), @@ -95,11 +187,34 @@ export namespace Vcs { branch: Effect.fn("Vcs.branch")(function* () { return yield* InstanceState.use(state, (x) => x.current) }), + defaultBranch: Effect.fn("Vcs.defaultBranch")(function* () { + return yield* InstanceState.use(state, (x) => x.root?.name) + }), + diff: Effect.fn("Vcs.diff")(function* (mode: Mode) { + const value = yield* InstanceState.get(state) + if (Instance.project.vcs !== "git") return [] + if (mode === "git") { + return yield* track( + fs, + git, + Instance.directory, + (yield* git.hasHead(Instance.directory)) ? "HEAD" : undefined, + ) + } + + if (!value.root) return [] + if (value.current && value.current === value.root.name) return [] + const ref = yield* git.mergeBase(Instance.directory, value.root.ref) + if (!ref) return [] + return yield* compare(fs, git, Instance.directory, ref) + }), }) }), ) - const runPromise = makeRunPromise(Service, layer) + export const defaultLayer = layer.pipe(Layer.provide(Git.defaultLayer), Layer.provide(AppFileSystem.defaultLayer)) + + const runPromise = makeRunPromise(Service, defaultLayer) export function init() { return runPromise((svc) => svc.init()) @@ -108,4 +223,12 @@ export namespace Vcs { export function branch() { return runPromise((svc) => svc.branch()) } + + export function defaultBranch() { + return runPromise((svc) => svc.defaultBranch()) + } + + export function diff(mode: Mode) { + return runPromise((svc) => svc.diff(mode)) + } } diff --git a/packages/opencode/test/git/git.test.ts b/packages/opencode/test/git/git.test.ts new file mode 100644 index 000000000000..a897a38e687e --- /dev/null +++ b/packages/opencode/test/git/git.test.ts @@ -0,0 +1,128 @@ +import { $ } from "bun" +import { describe, expect, test } from "bun:test" +import fs from "fs/promises" +import path from "path" +import { ManagedRuntime } from "effect" +import { Git } from "../../src/git" +import { tmpdir } from "../fixture/fixture" + +const weird = process.platform === "win32" ? "space file.txt" : "tab\tfile.txt" + +async function withGit(body: (rt: ManagedRuntime.ManagedRuntime) => Promise) { + const rt = ManagedRuntime.make(Git.defaultLayer) + try { + return await body(rt) + } finally { + await rt.dispose() + } +} + +describe("Git", () => { + test("branch() returns current branch name", async () => { + await using tmp = await tmpdir({ git: true }) + + await withGit(async (rt) => { + const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path))) + expect(branch).toBeDefined() + expect(typeof branch).toBe("string") + }) + }) + + test("branch() returns undefined for non-git directories", async () => { + await using tmp = await tmpdir() + + await withGit(async (rt) => { + const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path))) + expect(branch).toBeUndefined() + }) + }) + + test("branch() returns undefined for detached HEAD", async () => { + await using tmp = await tmpdir({ git: true }) + const hash = (await $`git rev-parse HEAD`.cwd(tmp.path).quiet().text()).trim() + await $`git checkout --detach ${hash}`.cwd(tmp.path).quiet() + + await withGit(async (rt) => { + const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path))) + expect(branch).toBeUndefined() + }) + }) + + test("defaultBranch() uses init.defaultBranch when available", async () => { + await using tmp = await tmpdir({ git: true }) + await $`git branch -M trunk`.cwd(tmp.path).quiet() + await $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet() + + await withGit(async (rt) => { + const branch = await rt.runPromise(Git.Service.use((git) => git.defaultBranch(tmp.path))) + expect(branch?.name).toBe("trunk") + expect(branch?.ref).toBe("trunk") + }) + }) + + test("status() handles special filenames", async () => { + await using tmp = await tmpdir({ git: true }) + await fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8") + + await withGit(async (rt) => { + const status = await rt.runPromise(Git.Service.use((git) => git.status(tmp.path))) + expect(status).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + file: weird, + status: "added", + }), + ]), + ) + }) + }) + + test("diff(), stats(), and mergeBase() parse tracked changes", async () => { + await using tmp = await tmpdir({ git: true }) + await $`git branch -M main`.cwd(tmp.path).quiet() + await fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8") + await $`git add .`.cwd(tmp.path).quiet() + await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet() + await $`git checkout -b feature/test`.cwd(tmp.path).quiet() + await fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8") + + await withGit(async (rt) => { + const [base, diff, stats] = await Promise.all([ + rt.runPromise(Git.Service.use((git) => git.mergeBase(tmp.path, "main"))), + rt.runPromise(Git.Service.use((git) => git.diff(tmp.path, "HEAD"))), + rt.runPromise(Git.Service.use((git) => git.stats(tmp.path, "HEAD"))), + ]) + + expect(base).toBeTruthy() + expect(diff).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + file: weird, + status: "modified", + }), + ]), + ) + expect(stats).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + file: weird, + additions: 1, + deletions: 1, + }), + ]), + ) + }) + }) + + test("show() returns empty text for binary blobs", async () => { + await using tmp = await tmpdir({ git: true }) + await fs.writeFile(path.join(tmp.path, "bin.dat"), new Uint8Array([0, 1, 2, 3])) + await $`git add .`.cwd(tmp.path).quiet() + await $`git commit --no-gpg-sign -m "add binary"`.cwd(tmp.path).quiet() + + await withGit(async (rt) => { + const text = await rt.runPromise(Git.Service.use((git) => git.show(tmp.path, "HEAD", "bin.dat"))) + expect(text).toBe("") + }) + }) +}) diff --git a/packages/opencode/test/project/vcs.test.ts b/packages/opencode/test/project/vcs.test.ts index 11463b795023..f55989caff34 100644 --- a/packages/opencode/test/project/vcs.test.ts +++ b/packages/opencode/test/project/vcs.test.ts @@ -23,7 +23,7 @@ function withVcs( ) { return withServices( directory, - Layer.merge(FileWatcher.layer, Vcs.layer), + Layer.merge(FileWatcher.layer, Vcs.defaultLayer), async (rt) => { await rt.runPromise(FileWatcher.Service.use((s) => s.init())) await rt.runPromise(Vcs.Service.use((s) => s.init())) @@ -34,7 +34,15 @@ function withVcs( ) } +function withVcsOnly( + directory: string, + body: (rt: ManagedRuntime.ManagedRuntime) => Promise, +) { + return withServices(directory, Vcs.defaultLayer, body) +} + type BranchEvent = { directory?: string; payload: { type: string; properties: { branch?: string } } } +const weird = process.platform === "win32" ? "space file.txt" : "tab\tfile.txt" /** Wait for a Vcs.Event.BranchUpdated event on GlobalBus, with retry polling as fallback */ function nextBranchUpdate(directory: string, timeout = 10_000) { @@ -123,3 +131,105 @@ describeVcs("Vcs", () => { }) }) }) + +describe("Vcs diff", () => { + afterEach(async () => { + await Instance.disposeAll() + }) + + test("defaultBranch() falls back to main", async () => { + await using tmp = await tmpdir({ git: true }) + await $`git branch -M main`.cwd(tmp.path).quiet() + + await withVcsOnly(tmp.path, async (rt) => { + const branch = await rt.runPromise(Vcs.Service.use((s) => s.defaultBranch())) + expect(branch).toBe("main") + }) + }) + + test("defaultBranch() uses init.defaultBranch when available", async () => { + await using tmp = await tmpdir({ git: true }) + await $`git branch -M trunk`.cwd(tmp.path).quiet() + await $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet() + + await withVcsOnly(tmp.path, async (rt) => { + const branch = await rt.runPromise(Vcs.Service.use((s) => s.defaultBranch())) + expect(branch).toBe("trunk") + }) + }) + + test("detects current branch from the active worktree", async () => { + await using tmp = await tmpdir({ git: true }) + await using wt = await tmpdir() + await $`git branch -M main`.cwd(tmp.path).quiet() + const dir = path.join(wt.path, "feature") + await $`git worktree add -b feature/test ${dir} HEAD`.cwd(tmp.path).quiet() + + await withVcsOnly(dir, async (rt) => { + const [branch, base] = await Promise.all([ + rt.runPromise(Vcs.Service.use((s) => s.branch())), + rt.runPromise(Vcs.Service.use((s) => s.defaultBranch())), + ]) + expect(branch).toBe("feature/test") + expect(base).toBe("main") + }) + }) + + test("diff('git') returns uncommitted changes", async () => { + await using tmp = await tmpdir({ git: true }) + await fs.writeFile(path.join(tmp.path, "file.txt"), "original\n", "utf-8") + await $`git add .`.cwd(tmp.path).quiet() + await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet() + await fs.writeFile(path.join(tmp.path, "file.txt"), "changed\n", "utf-8") + + await withVcsOnly(tmp.path, async (rt) => { + const diff = await rt.runPromise(Vcs.Service.use((s) => s.diff("git"))) + expect(diff).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + file: "file.txt", + status: "modified", + }), + ]), + ) + }) + }) + + test("diff('git') handles special filenames", async () => { + await using tmp = await tmpdir({ git: true }) + await fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8") + + await withVcsOnly(tmp.path, async (rt) => { + const diff = await rt.runPromise(Vcs.Service.use((s) => s.diff("git"))) + expect(diff).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + file: weird, + status: "added", + }), + ]), + ) + }) + }) + + test("diff('branch') returns changes against default branch", async () => { + await using tmp = await tmpdir({ git: true }) + await $`git branch -M main`.cwd(tmp.path).quiet() + await $`git checkout -b feature/test`.cwd(tmp.path).quiet() + await fs.writeFile(path.join(tmp.path, "branch.txt"), "hello\n", "utf-8") + await $`git add .`.cwd(tmp.path).quiet() + await $`git commit --no-gpg-sign -m "branch file"`.cwd(tmp.path).quiet() + + await withVcsOnly(tmp.path, async (rt) => { + const diff = await rt.runPromise(Vcs.Service.use((s) => s.diff("branch"))) + expect(diff).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + file: "branch.txt", + status: "added", + }), + ]), + ) + }) + }) +}) From 01d786ea76080d1f29cc9bc71d3f1fea0a4bcc0e Mon Sep 17 00:00:00 2001 From: Shoubhit Dash Date: Tue, 24 Mar 2026 13:43:45 +0530 Subject: [PATCH 03/13] core: add /vcs/diff endpoint to retrieve git diff for working tree or default branch comparison --- .../context/global-sync/event-reducer.test.ts | 10 +++--- .../src/context/global-sync/event-reducer.ts | 4 +-- packages/opencode/src/server/server.ts | 32 ++++++++++++++++-- packages/sdk/js/src/v2/gen/sdk.gen.ts | 33 +++++++++++++++++++ packages/sdk/js/src/v2/gen/types.gen.ts | 23 ++++++++++++- 5 files changed, 93 insertions(+), 9 deletions(-) diff --git a/packages/app/src/context/global-sync/event-reducer.test.ts b/packages/app/src/context/global-sync/event-reducer.test.ts index cf2da135cbbc..892129788e6c 100644 --- a/packages/app/src/context/global-sync/event-reducer.test.ts +++ b/packages/app/src/context/global-sync/event-reducer.test.ts @@ -494,8 +494,10 @@ describe("applyDirectoryEvent", () => { }) test("updates vcs branch in store and cache", () => { - const [store, setStore] = createStore(baseState()) - const [cacheStore, setCacheStore] = createStore({ value: undefined as State["vcs"] }) + const [store, setStore] = createStore(baseState({ vcs: { branch: "main", default_branch: "main" } })) + const [cacheStore, setCacheStore] = createStore({ + value: { branch: "main", default_branch: "main" } as State["vcs"], + }) applyDirectoryEvent({ event: { type: "vcs.branch.updated", properties: { branch: "feature/test" } }, @@ -511,8 +513,8 @@ describe("applyDirectoryEvent", () => { }, }) - expect(store.vcs).toEqual({ branch: "feature/test" }) - expect(cacheStore.value).toEqual({ branch: "feature/test" }) + expect(store.vcs).toEqual({ branch: "feature/test", default_branch: "main" }) + expect(cacheStore.value).toEqual({ branch: "feature/test", default_branch: "main" }) }) test("routes disposal and lsp events to side-effect handlers", () => { diff --git a/packages/app/src/context/global-sync/event-reducer.ts b/packages/app/src/context/global-sync/event-reducer.ts index b8eda0573f7b..0e243e95a36c 100644 --- a/packages/app/src/context/global-sync/event-reducer.ts +++ b/packages/app/src/context/global-sync/event-reducer.ts @@ -268,9 +268,9 @@ export function applyDirectoryEvent(input: { break } case "vcs.branch.updated": { - const props = event.properties as { branch: string } + const props = event.properties as { branch?: string } if (input.store.vcs?.branch === props.branch) break - const next = { branch: props.branch } + const next = { ...input.store.vcs, branch: props.branch } input.setStore("vcs", next) if (input.vcsCache) input.vcsCache.setStore("value", next) break diff --git a/packages/opencode/src/server/server.ts b/packages/opencode/src/server/server.ts index 7ead4df8a3cb..c2f3e64516ff 100644 --- a/packages/opencode/src/server/server.ts +++ b/packages/opencode/src/server/server.ts @@ -38,6 +38,7 @@ import { websocket } from "hono/bun" import { HTTPException } from "hono/http-exception" import { errors } from "./error" import { Filesystem } from "@/util/filesystem" +import { Snapshot } from "@/snapshot" import { QuestionRoutes } from "./routes/question" import { PermissionRoutes } from "./routes/permission" import { GlobalRoutes } from "./routes/global" @@ -330,12 +331,39 @@ export namespace Server { }, }), async (c) => { - const branch = await Vcs.branch() return c.json({ - branch, + branch: await Vcs.branch(), + default_branch: await Vcs.defaultBranch(), }) }, ) + .get( + "/vcs/diff", + describeRoute({ + summary: "Get VCS diff", + description: "Retrieve the current git diff for the working tree or against the default branch.", + operationId: "vcs.diff", + responses: { + 200: { + description: "VCS diff", + content: { + "application/json": { + schema: resolver(Snapshot.FileDiff.array()), + }, + }, + }, + }, + }), + validator( + "query", + z.object({ + mode: Vcs.Mode, + }), + ), + async (c) => { + return c.json(await Vcs.diff(c.req.valid("query").mode)) + }, + ) .get( "/command", describeRoute({ diff --git a/packages/sdk/js/src/v2/gen/sdk.gen.ts b/packages/sdk/js/src/v2/gen/sdk.gen.ts index 7a4f4e40cf30..5d559804c640 100644 --- a/packages/sdk/js/src/v2/gen/sdk.gen.ts +++ b/packages/sdk/js/src/v2/gen/sdk.gen.ts @@ -174,6 +174,7 @@ import type { TuiSelectSessionResponses, TuiShowToastResponses, TuiSubmitPromptResponses, + VcsDiffResponses, VcsGetResponses, WorktreeCreateErrors, WorktreeCreateInput, @@ -3719,6 +3720,38 @@ export class Vcs extends HeyApiClient { ...params, }) } + + /** + * Get VCS diff + * + * Retrieve the current git diff for the working tree or against the default branch. + */ + public diff( + parameters: { + directory?: string + workspace?: string + mode: "git" | "branch" + }, + options?: Options, + ) { + const params = buildClientParams( + [parameters], + [ + { + args: [ + { in: "query", key: "directory" }, + { in: "query", key: "workspace" }, + { in: "query", key: "mode" }, + ], + }, + ], + ) + return (options?.client ?? this.client).get({ + url: "/vcs/diff", + ...options, + ...params, + }) + } } export class Command extends HeyApiClient { diff --git a/packages/sdk/js/src/v2/gen/types.gen.ts b/packages/sdk/js/src/v2/gen/types.gen.ts index 86a0c7e42564..6ee94ec4d931 100644 --- a/packages/sdk/js/src/v2/gen/types.gen.ts +++ b/packages/sdk/js/src/v2/gen/types.gen.ts @@ -1889,7 +1889,8 @@ export type Path = { } export type VcsInfo = { - branch: string + branch?: string + default_branch?: string } export type Command = { @@ -4887,6 +4888,26 @@ export type VcsGetResponses = { export type VcsGetResponse = VcsGetResponses[keyof VcsGetResponses] +export type VcsDiffData = { + body?: never + path?: never + query: { + directory?: string + workspace?: string + mode: "git" | "branch" + } + url: "/vcs/diff" +} + +export type VcsDiffResponses = { + /** + * VCS diff + */ + 200: Array +} + +export type VcsDiffResponse = VcsDiffResponses[keyof VcsDiffResponses] + export type CommandListData = { body?: never path?: never From eb0399706571c9e6dc31e63e4f7f9ea6729a7e44 Mon Sep 17 00:00:00 2001 From: Shoubhit Dash Date: Tue, 24 Mar 2026 13:43:47 +0530 Subject: [PATCH 04/13] tui: allow users to switch between uncommitted changes and full branch diff in review panel --- packages/app/src/i18n/en.ts | 2 + packages/app/src/pages/session.tsx | 221 ++++++++++++++---- .../src/pages/session/session-side-panel.tsx | 58 ++--- .../pages/session/use-session-commands.tsx | 6 +- packages/ui/src/i18n/en.ts | 2 + 5 files changed, 208 insertions(+), 81 deletions(-) diff --git a/packages/app/src/i18n/en.ts b/packages/app/src/i18n/en.ts index 579b740d3aee..6a5d80742c5a 100644 --- a/packages/app/src/i18n/en.ts +++ b/packages/app/src/i18n/en.ts @@ -535,6 +535,8 @@ export const dict = { "session.review.noVcs.createGit.action": "Create Git repository", "session.review.noSnapshot": "Snapshot tracking is disabled in config, so session changes are unavailable", "session.review.noChanges": "No changes", + "session.review.noUncommittedChanges": "No uncommitted changes yet", + "session.review.noBranchChanges": "No branch changes yet", "session.files.selectToOpen": "Select a file to open", "session.files.all": "All files", diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx index 428826f6ad97..0d7a2090934a 100644 --- a/packages/app/src/pages/session.tsx +++ b/packages/app/src/pages/session.tsx @@ -1,4 +1,4 @@ -import type { Project, UserMessage } from "@opencode-ai/sdk/v2" +import type { FileDiff, Project, UserMessage } from "@opencode-ai/sdk/v2" import { useDialog } from "@opencode-ai/ui/context/dialog" import { useMutation } from "@tanstack/solid-query" import { @@ -58,6 +58,9 @@ import { formatServerError } from "@/utils/server-errors" const emptyUserMessages: UserMessage[] = [] const emptyFollowups: (FollowupDraft & { id: string })[] = [] +type ChangeMode = "git" | "branch" | "session" | "turn" +type VcsMode = "git" | "branch" + type SessionHistoryWindowInput = { sessionID: () => string | undefined messagesReady: () => boolean @@ -413,15 +416,16 @@ export default function Page() { const info = createMemo(() => (params.id ? sync.session.get(params.id) : undefined)) const diffs = createMemo(() => (params.id ? (sync.data.session_diff[params.id] ?? []) : [])) - const reviewCount = createMemo(() => Math.max(info()?.summary?.files ?? 0, diffs().length)) - const hasReview = createMemo(() => reviewCount() > 0) + const sessionCount = createMemo(() => Math.max(info()?.summary?.files ?? 0, diffs().length)) + const hasSessionReview = createMemo(() => sessionCount() > 0) + const canReview = createMemo(() => !!params.id) const reviewTab = createMemo(() => isDesktop()) const tabState = createSessionTabs({ tabs, pathFromTab: file.pathFromTab, normalizeTab, review: reviewTab, - hasReview, + hasReview: canReview, }) const contextOpen = tabState.contextOpen const openedTabs = tabState.openedTabs @@ -444,6 +448,12 @@ export default function Page() { if (!id) return false return sync.session.history.loading(id) }) + const diffsReady = createMemo(() => { + const id = params.id + if (!id) return true + if (!hasSessionReview()) return true + return sync.data.session_diff[id] !== undefined + }) const userMessages = createMemo( () => messages().filter((m) => m.role === "user") as UserMessage[], @@ -497,11 +507,22 @@ export default function Page() { const [store, setStore] = createStore({ messageId: undefined as string | undefined, mobileTab: "session" as "session" | "changes", - changes: "session" as "session" | "turn", + changes: "git" as ChangeMode, newSessionWorktree: "main", deferRender: false, }) + const [vcs, setVcs] = createStore({ + diff: { + git: [] as FileDiff[], + branch: [] as FileDiff[], + }, + ready: { + git: false, + branch: false, + }, + }) + const [followup, setFollowup] = createStore({ items: {} as Record, failed: {} as Record, @@ -528,6 +549,40 @@ export default function Page() { let refreshTimer: number | undefined let diffFrame: number | undefined let diffTimer: number | undefined + const vcsTask = new Map>() + + const resetVcs = () => { + vcsTask.clear() + setVcs({ + diff: { git: [], branch: [] }, + ready: { git: false, branch: false }, + }) + } + + const loadVcs = (mode: VcsMode, force = false) => { + if (sync.project?.vcs !== "git") return Promise.resolve() + if (vcs.ready[mode] && !force) return Promise.resolve() + const current = vcsTask.get(mode) + if (current) return current + + const task = sdk.client.vcs + .diff({ mode }) + .then((result) => { + setVcs("diff", mode, result.data ?? []) + setVcs("ready", mode, true) + }) + .catch((error) => { + console.debug("[session-review] failed to load vcs diff", { mode, error }) + setVcs("diff", mode, []) + setVcs("ready", mode, true) + }) + .finally(() => { + vcsTask.delete(mode) + }) + + vcsTask.set(mode, task) + return task + } createComputed((prev) => { const open = desktopReviewOpen() @@ -543,7 +598,42 @@ export default function Page() { }, desktopReviewOpen()) const turnDiffs = createMemo(() => lastUserMessage()?.summary?.diffs ?? []) - const reviewDiffs = createMemo(() => (store.changes === "session" ? diffs() : turnDiffs())) + const changesOptions = createMemo(() => { + const list: ChangeMode[] = [] + if (sync.project?.vcs === "git") list.push("git") + if ( + sync.project?.vcs === "git" && + sync.data.vcs?.branch && + sync.data.vcs?.default_branch && + sync.data.vcs.branch !== sync.data.vcs.default_branch + ) { + list.push("branch") + } + list.push("session", "turn") + return list + }) + const vcsMode = createMemo(() => { + if (store.changes === "git" || store.changes === "branch") return store.changes + }) + const reviewDiffs = createMemo(() => { + if (store.changes === "git") return vcs.diff.git + if (store.changes === "branch") return vcs.diff.branch + if (store.changes === "session") return diffs() + return turnDiffs() + }) + const reviewCount = createMemo(() => { + if (store.changes === "git") return vcs.diff.git.length + if (store.changes === "branch") return vcs.diff.branch.length + if (store.changes === "session") return sessionCount() + return turnDiffs().length + }) + const hasReview = createMemo(() => reviewCount() > 0) + const reviewReady = createMemo(() => { + if (store.changes === "git") return vcs.ready.git + if (store.changes === "branch") return vcs.ready.branch + if (store.changes === "session") return !hasSessionReview() || diffsReady() + return true + }) const newSessionWorktree = createMemo(() => { if (store.newSessionWorktree === "create") return "create" @@ -609,13 +699,7 @@ export default function Page() { scrollToMessage(msgs[targetIndex], "auto") } - const diffsReady = createMemo(() => { - const id = params.id - if (!id) return true - if (!hasReview()) return true - return sync.data.session_diff[id] !== undefined - }) - const reviewEmptyKey = createMemo(() => { + const sessionEmptyKey = createMemo(() => { const project = sync.project if (project && !project.vcs) return "session.review.noVcs" if (sync.data.config.snapshot === false) return "session.review.noSnapshot" @@ -737,13 +821,23 @@ export default function Page() { sessionKey, () => { setStore("messageId", undefined) - setStore("changes", "session") + setStore("changes", "git") setUi("pendingMessage", undefined) }, { defer: true }, ), ) + createEffect( + on( + () => sdk.directory, + () => { + resetVcs() + }, + { defer: true }, + ), + ) + createEffect( on( () => params.dir, @@ -866,6 +960,40 @@ export default function Page() { } const mobileChanges = createMemo(() => !isDesktop() && store.mobileTab === "changes") + const wantsReview = createMemo(() => + isDesktop() + ? desktopFileTreeOpen() || (desktopReviewOpen() && activeTab() === "review") + : store.mobileTab === "changes", + ) + + createEffect(() => { + const list = changesOptions() + if (list.includes(store.changes)) return + const next = list[0] + if (!next) return + setStore("changes", next) + }) + + createEffect(() => { + const mode = vcsMode() + if (!mode) return + if (!wantsReview()) return + void loadVcs(mode) + }) + + createEffect( + on( + () => sync.data.session_status[params.id ?? ""]?.type, + (next, prev) => { + const mode = vcsMode() + if (!mode) return + if (!wantsReview()) return + if (next !== "idle" || prev === undefined || prev === "idle") return + void loadVcs(mode, true) + }, + { defer: true }, + ), + ) const fileTreeTab = () => layout.fileTree.tab() const setFileTreeTab = (value: "changes" | "all") => layout.fileTree.setTab(value) @@ -912,21 +1040,23 @@ export default function Page() { loadFile: file.load, }) - const changesOptions = ["session", "turn"] as const - const changesOptionsList = [...changesOptions] - const changesTitle = () => { - if (!hasReview()) { + if (!canReview()) { return null } + const label = (option: ChangeMode) => { + if (option === "git") return language.t("ui.sessionReview.title.git") + if (option === "branch") return language.t("ui.sessionReview.title.branch") + if (option === "session") return language.t("ui.sessionReview.title") + return language.t("ui.sessionReview.title.lastTurn") + } + return (