import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
import { SourceControlProviderKind } from "@t3tools/contracts";
// @effect-diagnostics nodeBuiltinImport:off
import * as NodeFS from "node:fs";
import * as NodePath from "node:path";
import * as NodeChildProcess from "node:child_process";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Deferred from "effect/Deferred";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as PlatformError from "effect/PlatformError";
import * as Result from "effect/Result";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import { ChildProcessSpawner } from "effect/process";
import { expect } from "vite-plus/test";
import type {
ChangeRequest,
GitActionProgressEvent,
GitPreparePullRequestThreadInput,
ModelSelection,
} from "@t3tools/contracts";
import {
DEFAULT_SERVER_SETTINGS,
EventId,
GitCommandError,
MessageId,
ProjectId,
ProviderDriverKind,
ProviderInstanceId,
RunId,
SourceControlProviderError as SourceControlProviderFailure,
TextGenerationError,
ThreadId,
TurnItemId,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as TextGeneration from "../textGeneration/TextGeneration.ts";
import {
fromRunner,
decodeJsonReply,
} from "@t3tools/provider-core/server/textGenerationOperations";
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
import * as VcsProcess from "../vcs/VcsProcess.ts";
import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
import * as VcsProjectConfig from "../vcs/VcsProjectConfig.ts";
import * as GitWorkflowService from "./GitWorkflowService.ts";
import type { SourceControlProvider } from "@t3tools/source-control-core/server/SourceControlProvider";
import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import * as ServerConfig from "../config.ts";
import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
import * as ProjectStore from "../orchestration-v2/ProjectStore.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as GitManager from "./GitManager.ts";
/** A change request the fake host reports. Omitted fields read as an open, undated request. */
type FakeChangeRequest = Omit<ChangeRequest, "provider" | "state" | "updatedAt"> & {
readonly state?: ChangeRequest["state"];
readonly updatedAt?: string;
};
interface FakeProviderScenario {
prListGate?: {
readonly started: Deferred.Deferred<void>;
readonly release: Deferred.Deferred<void>;
};
/** The kind the fake host reports itself as. */
kind?: string;
/** Answers to successive change request listings, whatever their head selector. */
prListSequence?: ReadonlyArray<ReadonlyArray<FakeChangeRequest>>;
prListByHeadSelector?: Record<string, ReadonlyArray<FakeChangeRequest>>;
prListSequenceByHeadSelector?: Record<string, ReadonlyArray<ReadonlyArray<FakeChangeRequest>>>;
/** The answer to every listing the other lists leave unanswered. */
prListOtherwise?: ReadonlyArray<FakeChangeRequest>;
defaultBranch?: string;
pullRequest?: FakeChangeRequest;
repositoryCloneUrls?: Record<string, { url: string; sshUrl: string }>;
failWith?: string;
failCause?: unknown;
failAfterCalls?: number;
/** Check out the pull request head from its pull ref: fast-forward only unless forced. */
syncCheckoutWithPullHead?: boolean;
/**
* The host's `headBranchProbe`. By default the fake probes only bare branch names, a hundred
* at a time, so tests see GitManager defer to the hook; null leaves the probe to GitManager.
*/
headBranchProbe?: SourceControlProvider["Service"]["headBranchProbe"] | null;
}
type FakeProviderCall =
| {
readonly operation: "listChangeRequests";
readonly headSelector: string;
readonly state: string;
readonly limit: number | undefined;
}
| {
readonly operation: "createChangeRequest";
readonly baseRefName: string;
readonly headSelector: string;
readonly title: string;
}
| { readonly operation: "getChangeRequest"; readonly reference: string }
| {
readonly operation: "checkoutChangeRequest";
readonly reference: string;
readonly force: boolean;
}
| { readonly operation: "getRepositoryCloneUrls"; readonly repository: string }
| { readonly operation: "getDefaultBranch" };
const listed = (calls: ReadonlyArray<FakeProviderCall>) =>
calls.flatMap((call) => (call.operation === "listChangeRequests" ? [call] : []));
const listedSelectors = (calls: ReadonlyArray<FakeProviderCall>) =>
listed(calls).map((call) => call.headSelector);
const created = (calls: ReadonlyArray<FakeProviderCall>) =>
calls.flatMap((call) =>
call.operation === "createChangeRequest"
? [{ baseRefName: call.baseRefName, headSelector: call.headSelector }]
: [],
);
type FakeGitTextGeneration = TextGeneration.TextGeneration["Service"];
function runGitSyncForFakeCheckout(cwd: string, args: readonly string[]): void {
const result = NodeChildProcess.spawnSync("git", args, {
cwd,
encoding: "utf8",
});
if (result.status === 0) {
return;
}
throw new Error(
`Failed to simulate a host checkout with git ${args.join(" ")}: ${result.stderr?.trim() || "unknown error"}`,
);
}
function makeTempDir(
prefix: string,
): Effect.Effect<string, PlatformError.PlatformError, FileSystem.FileSystem | Scope.Scope> {
return Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
return yield* fileSystem.makeTempDirectoryScoped({ prefix });
});
}
function removePath(
targetPath: string,
): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem> {
return Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
yield* fileSystem.remove(targetPath, { recursive: true, force: true });
});
}
function makeDirectory(
dirPath: string,
): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem> {
return Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
yield* fileSystem.makeDirectory(dirPath, { recursive: true });
});
}
function runGit(
cwd: string,
args: readonly string[],
allowNonZeroExit = false,
): Effect.Effect<
{
readonly exitCode: GitVcsDriver.ExecuteGitResult["exitCode"];
readonly stdout: string;
readonly stderr: string;
},
GitCommandError,
GitVcsDriver.GitVcsDriver
> {
return Effect.gen(function* () {
const git = yield* GitVcsDriver.GitVcsDriver;
const result = yield* git.execute({
operation: "GitManager.test.runGit",
cwd,
args,
allowNonZeroExit,
});
return {
exitCode: result.exitCode,
stdout: result.stdout,
stderr: result.stderr,
};
});
}
function initRepo(
cwd: string,
): Effect.Effect<
void,
PlatformError.PlatformError | GitCommandError,
FileSystem.FileSystem | Scope.Scope | GitVcsDriver.GitVcsDriver
> {
return Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
yield* runGit(cwd, ["init", "--initial-branch=main"]);
yield* runGit(cwd, ["config", "user.email", "test@example.com"]);
yield* runGit(cwd, ["config", "user.name", "Test User"]);
// Override global autocrlf on Windows for LF assertions, including linked worktrees.
yield* runGit(cwd, ["config", "core.autocrlf", "false"]);
yield* fs.writeFileString(NodePath.join(cwd, "README.md"), "hello\n");
yield* runGit(cwd, ["add", "README.md"]);
yield* runGit(cwd, ["commit", "-m", "Initial commit"]);
});
}
function createBareRemote(): Effect.Effect<
string,
PlatformError.PlatformError | GitCommandError,
FileSystem.FileSystem | Scope.Scope | GitVcsDriver.GitVcsDriver
> {
return Effect.gen(function* () {
const remoteDir = yield* makeTempDir("t3code-git-remote-");
yield* runGit(remoteDir, ["init", "--bare"]);
return remoteDir;
});
}
function configureRemote(
cwd: string,
remoteName: string,
remotePath: string,
fetchNamespace: string,
): Effect.Effect<void, GitCommandError, GitVcsDriver.GitVcsDriver> {
return Effect.gen(function* () {
yield* runGit(cwd, ["config", `remote.${remoteName}.url`, remotePath]);
yield* runGit(cwd, [
"config",
"--replace-all",
`remote.${remoteName}.fetch`,
`+refs/heads/*:refs/remotes/${fetchNamespace}/*`,
]);
});
}
function configureVisibleRemoteUrlWithLocalRewrite(
cwd: string,
remoteName: string,
visibleUrl: string,
localRemotePath: string,
): Effect.Effect<void, GitCommandError, GitVcsDriver.GitVcsDriver> {
return Effect.gen(function* () {
yield* runGit(cwd, ["config", `remote.${remoteName}.url`, visibleUrl]);
yield* runGit(cwd, ["config", `url.${localRemotePath}.insteadOf`, visibleUrl]);
});
}
function createTextGeneration(
overrides: Partial<FakeGitTextGeneration> = {},
): TextGeneration.TextGeneration["Service"] {
const implementation: FakeGitTextGeneration = {
generateCommitMessage: (input) =>
Effect.succeed({
subject: "Implement stacked git actions",
body: "",
...(input.includeBranch ? { branch: "feature/implement-stacked-git-actions" } : {}),
}),
generatePrContent: () =>
Effect.succeed({
title: "Add stacked git actions",
body: "## Summary\n- Add stacked git workflow\n\n## Testing\n- Not run",
}),
generateBranchName: () =>
Effect.succeed({
branch: "update-workflow",
}),
generateThreadTitle: () =>
Effect.succeed({
title: "Update workflow",
}),
generateReviewGuide: () => Effect.succeed({ stops: [] }),
generateTranscriptionPostProcessing: () =>
Effect.succeed({ transcription: "processed transcript" }),
...overrides,
};
return {
generateCommitMessage: (input) =>
implementation.generateCommitMessage(input).pipe(
Effect.mapError(
(cause) =>
new TextGenerationError({
operation: "generateCommitMessage",
detail: "fake text generation failed",
...(cause !== undefined ? { cause } : {}),
}),
),
),
generatePrContent: (input) =>
implementation.generatePrContent(input).pipe(
Effect.mapError(
(cause) =>
new TextGenerationError({
operation: "generatePrContent",
detail: "fake text generation failed",
...(cause !== undefined ? { cause } : {}),
}),
),
),
generateBranchName: (input) =>
implementation.generateBranchName(input).pipe(
Effect.mapError(
(cause) =>
new TextGenerationError({
operation: "generateBranchName",
detail: "fake text generation failed",
...(cause !== undefined ? { cause } : {}),
}),
),
),
generateThreadTitle: (input) =>
implementation.generateThreadTitle(input).pipe(
Effect.mapError(
(cause) =>
new TextGenerationError({
operation: "generateThreadTitle",
detail: "fake text generation failed",
...(cause !== undefined ? { cause } : {}),
}),
),
),
generateReviewGuide: (input) => implementation.generateReviewGuide(input),
generateTranscriptionPostProcessing: (input) =>
implementation.generateTranscriptionPostProcessing(input),
};
}
/**
* A host that answers from the scenario and records what it was asked, so tests assert on the
* selectors GitManager chose rather than on any host's wire format.
*/
function createFakeSourceControlProvider(scenario: FakeProviderScenario = {}): {
service: SourceControlProvider["Service"];
calls: FakeProviderCall[];
} {
const kind = SourceControlProviderKind.make(scenario.kind ?? "github");
const prListQueue = [...(scenario.prListSequence ?? [])];
const prListQueueByHeadSelector = new Map(
Object.entries(scenario.prListSequenceByHeadSelector ?? {}).map(([headSelector, values]) => [
headSelector,
[...values],
]),
);
const calls: FakeProviderCall[] = [];
const record = (cwd: string, call: FakeProviderCall) =>
Effect.suspend(() => {
calls.push(call);
return scenario.failWith && calls.length > (scenario.failAfterCalls ?? 0)
? Effect.fail(
new SourceControlProviderFailure({
provider: kind,
operation: call.operation,
cwd,
detail: scenario.failWith,
cause: scenario.failCause,
}),
)
: Effect.void;
});
const toChangeRequest = (summary: FakeChangeRequest): ChangeRequest => ({
...summary,
provider: kind,
state: summary.state ?? "open",
closedAt: summary.closedAt ?? null,
mergedAt: summary.mergedAt ?? null,
updatedAt:
summary.updatedAt === undefined
? Option.none()
: Option.some(DateTime.makeUnsafe(summary.updatedAt)),
});
const pullRequest = (): FakeChangeRequest =>
scenario.pullRequest ?? {
number: 101,
title: "Pull request",
url: "https://github.com/pingdotgg/codething-mvp/pull/101",
baseRefName: "main",
headRefName: "feature/pull-request",
state: "open",
};
const checkout = (cwd: string, force: boolean) => {
const headBranch = scenario.pullRequest?.headRefName;
if (!headBranch) return;
const existingBranch = NodeChildProcess.spawnSync(
"git",
["show-ref", "--verify", "--quiet", `refs/heads/${headBranch}`],
{ cwd },
);
if (scenario.syncCheckoutWithPullHead) {
runGitSyncForFakeCheckout(cwd, [
"fetch",
"origin",
`refs/pull/${scenario.pullRequest?.number}/head`,
]);
if (existingBranch.status === 0) {
runGitSyncForFakeCheckout(cwd, ["checkout", headBranch]);
runGitSyncForFakeCheckout(
cwd,
force ? ["reset", "--hard", "FETCH_HEAD"] : ["merge", "--ff-only", "FETCH_HEAD"],
);
} else {
runGitSyncForFakeCheckout(cwd, ["checkout", "-b", headBranch, "FETCH_HEAD"]);
}
} else if (existingBranch.status === 0) {
runGitSyncForFakeCheckout(cwd, ["checkout", headBranch]);
} else {
runGitSyncForFakeCheckout(cwd, ["checkout", "-b", headBranch]);
}
};
const headBranchProbe =
scenario.headBranchProbe === null
? {}
: {
headBranchProbe:
scenario.headBranchProbe ??
(({ headSelectors }: { readonly headSelectors: ReadonlyArray<string> }) => ({
headSelectors: headSelectors.filter((selector) => !selector.includes(":")),
limit: 100,
})),
};
return {
service: {
kind,
...headBranchProbe,
listChangeRequests: (input) =>
record(input.cwd, {
operation: "listChangeRequests",
headSelector: input.headSelector,
state: input.state,
limit: input.limit,
}).pipe(
Effect.map(() =>
(
prListQueueByHeadSelector.get(input.headSelector)?.shift() ??
scenario.prListByHeadSelector?.[input.headSelector] ??
prListQueue.shift() ??
scenario.prListOtherwise ??
[]
).map(toChangeRequest),
),
Effect.tap(() =>
scenario.prListGate
? Deferred.succeed(scenario.prListGate.started, undefined).pipe(
Effect.andThen(Deferred.await(scenario.prListGate.release)),
)
: Effect.void,
),
),
createChangeRequest: (input) =>
record(input.cwd, {
operation: "createChangeRequest",
baseRefName: input.baseRefName,
headSelector: input.headSelector,
title: input.title,
}),
getDefaultBranch: (input) =>
record(input.cwd, { operation: "getDefaultBranch" }).pipe(
Effect.map(() => {
const value = (scenario.defaultBranch ?? "main").trim();
return value.length > 0 ? value : null;
}),
),
getChangeRequest: (input) =>
record(input.cwd, { operation: "getChangeRequest", reference: input.reference }).pipe(
Effect.map(() => toChangeRequest(pullRequest())),
),
getRepositoryCloneUrls: (input) =>
record(input.cwd, {
operation: "getRepositoryCloneUrls",
repository: input.repository,
}).pipe(
Effect.flatMap(() => {
const repository = input.host ? `${input.host}/${input.repository}` : input.repository;
const cloneUrls =
scenario.repositoryCloneUrls?.[repository] ??
(input.host === "github.com"
? scenario.repositoryCloneUrls?.[input.repository]
: undefined);
return cloneUrls
? Effect.succeed({ nameWithOwner: input.repository, ...cloneUrls })
: Effect.fail(
new SourceControlProviderFailure({
provider: kind,
operation: "getRepositoryCloneUrls",
cwd: input.cwd,
detail: `Unexpected repository lookup: ${input.repository}`,
}),
);
}),
),
createRepository: (input) =>
Effect.fail(
new SourceControlProviderFailure({
provider: kind,
operation: "createRepository",
cwd: input.cwd,
detail: `Unexpected repository create: ${input.repository}`,
}),
),
checkoutChangeRequest: (input) =>
record(input.cwd, {
operation: "checkoutChangeRequest",
reference: input.reference,
force: input.force ?? false,
}).pipe(
Effect.flatMap(() =>
Effect.try({
try: () => checkout(input.cwd, input.force ?? false),
catch: (cause) =>
new SourceControlProviderFailure({
provider: kind,
operation: "checkoutChangeRequest",
cwd: input.cwd,
detail: "Host checkout failed.",
cause,
}),
}),
),
),
},
calls,
};
}
/**
* Reads a template from the base tree the way a host would, without any host's own lookup
* rules, so tests see which tree GitManager reads it from.
*/
const readFakeChangeRequestTemplate = Effect.fnUntraced(function* (input: {
readonly cwd: string;
readonly treeish: string;
}) {
const git = yield* GitVcsDriver.GitVcsDriver;
const result = yield* git
.execute({
operation: "GitManager.test.readTemplate",
cwd: input.cwd,
args: ["show", `${input.treeish}:.github/pull_request_template.md`],
allowNonZeroExit: true,
})
.pipe(Effect.orDie);
const template = result.stdout.trim();
return result.exitCode === 0 && template.length > 0 ? Option.some(template) : Option.none();
});
function runStackedAction(
manager: GitManager.GitManager["Service"],
input: {
cwd: string;
action: "commit" | "push" | "create_pr" | "commit_push" | "commit_push_pr";
actionId?: string;
commitMessage?: string;
featureBranch?: boolean;
filePaths?: readonly string[];
},
options?: Parameters<GitManager.GitManager["Service"]["runStackedAction"]>[1],
) {
return manager.runStackedAction(
{
...input,
actionId: input.actionId ?? "test-action-id",
},
options,
);
}
function preparePullRequestThread(
manager: GitManager.GitManager["Service"],
input: GitPreparePullRequestThreadInput,
) {
return manager.preparePullRequestThread(input);
}
function makeManager(input?: {
providerScenario?: FakeProviderScenario;
sourceControlProvider?: SourceControlProvider["Service"];
textGeneration?: Partial<FakeGitTextGeneration>;
serverSettings?: Parameters<typeof ServerSettings.layerTest>[0];
setupScriptRunner?: ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"];
gitConfigReads?: string[];
gitCommands?: string[];
gitSpawnGate?: {
readonly matches: (args: ReadonlyArray<string>) => boolean;
readonly reached: Deferred.Deferred<void>;
readonly release: Deferred.Deferred<void>;
};
seed?: Effect.Effect<
void,
ProjectionStore.ProjectionStoreV2Error | ProjectStore.ProjectStoreV2Error,
ProjectionStore.ProjectionStoreV2 | ProjectStore.ProjectStoreV2
>;
}) {
const { service: fakeProvider, calls: providerCalls } = createFakeSourceControlProvider(
input?.providerScenario,
);
const textGeneration = createTextGeneration(input?.textGeneration);
const layerServerConfig = ServerConfig.layerTest(process.cwd(), {
prefix: "t3-git-manager-test-",
});
const layerServerSettings = ServerSettings.ServerSettingsService.layerTest(input?.serverSettings);
const gitCommands = input?.gitCommands;
const gitSpawnGate = input?.gitSpawnGate;
const watchesGitSpawns = gitCommands !== undefined || gitSpawnGate !== undefined;
const layerGitDriverSpawner = watchesGitSpawns
? Layer.effect(
ChildProcessSpawner.ChildProcessSpawner,
Effect.gen(function* () {
const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
return ChildProcessSpawner.make((command) => {
// On Windows the driver starts git by its full path to git.exe.
const args =
command._tag === "StandardCommand" &&
NodePath.parse(command.command).name.toLowerCase() === "git"
? command.args.map(String)
: null;
if (args !== null) gitCommands?.push(args.join(" "));
if (args === null || gitSpawnGate === undefined || !gitSpawnGate.matches(args)) {
return spawner.spawn(command);
}
return spawner
.spawn(command)
.pipe(
Effect.tap((handle) =>
handle.exitCode.pipe(
Effect.andThen(Deferred.succeed(gitSpawnGate.reached, undefined)),
Effect.andThen(Deferred.await(gitSpawnGate.release)),
),
),
);
});
}),
).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)))
: Layer.empty;
const gitVcsDriver = input?.gitConfigReads
? Layer.effect(
GitVcsDriver.GitVcsDriver,
GitVcsDriver.make.pipe(
Effect.map((service) =>
GitVcsDriver.GitVcsDriver.of({
...service,
readConfigValue: (cwd, key) =>
Effect.sync(() => input.gitConfigReads?.push(key)).pipe(
Effect.andThen(service.readConfigValue(cwd, key)),
),
}),
),
),
)
: GitVcsDriver.layer;
const layerVcsDriver = (watchesGitSpawns ? Layer.fresh(gitVcsDriver) : gitVcsDriver).pipe(
Layer.provide(layerGitDriverSpawner),
Layer.provideMerge(VcsProcess.layer),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
Layer.provideMerge(layerServerConfig),
);
const layerSourceControlRegistry = Layer.effect(
SourceControlProviderRegistry.SourceControlProviderRegistry,
Effect.gen(function* () {
const context = yield* Effect.context<GitVcsDriver.GitVcsDriver>();
return (
input?.sourceControlProvider ?? {
...fakeProvider,
readChangeRequestTemplate: (template: { cwd: string; treeish: string }) =>
readFakeChangeRequestTemplate(template).pipe(Effect.provideContext(context)),
}
);
}).pipe(
Effect.map((provider) =>
SourceControlProviderRegistry.SourceControlProviderRegistry.of({
resolveLink: (input) => provider.resolveLink?.(input),
get: () => Effect.succeed(provider),
resolveHandle: () => Effect.succeed({ provider, context: null }),
resolve: () => Effect.succeed(provider),
discover: Effect.succeed([]),
}),
),
),
);
const layerManager = Layer.mergeAll(
Layer.succeed(TextGeneration.TextGeneration, textGeneration),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
}),
Layer.succeed(
ProjectSetupScriptRunner.ProjectSetupScriptRunner,
input?.setupScriptRunner ?? {
runForThread: () => Effect.succeed({ status: "no-script" as const }),
},
),
layerServerSettings,
).pipe(
Layer.provideMerge(layerSourceControlRegistry),
Layer.provideMerge(layerVcsDriver),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
const layerStores = Layer.merge(ProjectionStore.layer, ProjectStore.layer).pipe(
Layer.provideMerge(SqlitePersistence.layerMemory),
);
return Effect.gen(function* () {
const stores = yield* Layer.build(layerStores);
if (input?.seed !== undefined) {
yield* input.seed.pipe(Effect.provideContext(stores), Effect.orDie);
}
const manager = yield* GitManager.make.pipe(
Effect.provide(layerManager),
Effect.provideContext(stores),
);
return { manager, providerCalls };
});
}
const asThreadId = (threadId: string) => threadId as ThreadId;
const layerGitManagerTest = GitVcsDriver.layer.pipe(
Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-git-manager-test-" })),
Layer.provideMerge(VcsProcess.layer),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
it.layer(layerGitManagerTest)("GitManager", (it) => {
it.effect(
"publishes local Git changes during a held PR lookup without caching its old branch",
() =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-refresh-status-gh-gate-");
yield* initRepo(repoDir);
yield* runGit(repoDir, ["checkout", "-b", "release"]);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "release"]);
yield* runGit(repoDir, ["tag", "release"]);
const oldPr = {
number: 613,
title: "Release PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/613",
baseRefName: "main",
headRefName: "release",
};
const newPr = { ...oldPr, number: 614, headRefName: "heads/release" };
const providerScenario: FakeProviderScenario = {
prListSequence: [oldPr, oldPr, newPr].map((pr) => [pr]),
};
const { manager } = yield* makeManager({ providerScenario });
const context = yield* Layer.build(
VcsStatusBroadcaster.layer.pipe(
Layer.provide(
GitWorkflowService.layer.pipe(
Layer.provide(Layer.succeed(GitManager.GitManager, manager)),
Layer.provide(
VcsDriverRegistry.layer.pipe(
Layer.provide(VcsProjectConfig.layer),
Layer.provide(VcsProcess.layer),
),
),
),
),
Layer.provide(
Layer.mock(BackgroundPolicy.BackgroundPolicy)({
shouldRunScopeWork: () => Effect.succeed(true),
}),
),
),
);
const broadcaster = Context.get(context, VcsStatusBroadcaster.VcsStatusBroadcaster);
const initial = yield* broadcaster.getStatus({ cwd: repoDir });
expect(initial.refName).toBe("release");
expect(initial.pr?.number).toBe(613);
const subscribed = yield* Deferred.make<void>();
const published = yield* Deferred.make<void>();
yield* broadcaster.streamStatus({ cwd: repoDir, includeRemote: false }).pipe(
Stream.runForEach((event) => {
if (event._tag === "snapshot") return Deferred.succeed(subscribed, undefined);
if (event._tag === "localUpdated" && event.local.hasWorkingTreeChanges) {
return Deferred.succeed(published, undefined);
}
return Effect.void;
}),
Effect.forkScoped,
);
yield* Deferred.await(subscribed);
const gate = {
started: yield* Deferred.make<void>(),
release: yield* Deferred.make<void>(),
};
providerScenario.prListGate = gate;
const fs = yield* FileSystem.FileSystem;
yield* fs.writeFileString(NodePath.join(repoDir, "README.md"), "changed before refresh\n");
const completed = yield* Deferred.make<void>();
const refresh = yield* broadcaster
.refreshStatus(repoDir)
.pipe(Effect.ensuring(Deferred.succeed(completed, undefined)), Effect.forkScoped);
yield* Deferred.await(gate.started);
const pending = Option.getOrThrow(
yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
);
expect(pending._tag).toBe("snapshot");
if (pending._tag === "snapshot") expect(pending.local.hasWorkingTreeChanges).toBe(true);
yield* Deferred.await(published);
expect(yield* Deferred.isDone(completed)).toBe(false);
yield* runGit(repoDir, ["checkout", "-b", "heads/release"]);
yield* runGit(repoDir, ["push", "-u", "origin", "refs/heads/heads/release"]);
yield* Deferred.succeed(gate.release, undefined);
const refreshed = yield* Fiber.join(refresh);
expect(refreshed.refName).toBe("heads/release");
expect(refreshed.hasWorkingTreeChanges).toBe(true);
expect(refreshed.pr).toBeNull();
const snapshot = Option.getOrThrow(
yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
);
expect(snapshot._tag).toBe("snapshot");
if (snapshot._tag === "snapshot") expect(snapshot.remote).toBeNull();
delete providerScenario.prListGate;
const recovered = yield* broadcaster.getStatus({ cwd: repoDir });
expect(recovered.refName).toBe("heads/release");
expect(recovered.pr?.number).toBe(614);
expect((yield* broadcaster.getStatus({ cwd: repoDir })).pr?.number).toBe(614);
}),
);
it.effect("status reports the listed PR whose head is the branch", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
yield* runGit(repoDir, ["checkout", "-b", "feature/status-valid-pr-entry"]);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/status-valid-pr-entry"]);
const { manager } = yield* makeManager({
providerScenario: {
prListSequence: [
[
{
number: 14,
title: "Another branch",
url: "https://github.com/pingdotgg/codething-mvp/pull/14",
baseRefName: "main",
headRefName: "feature/another-branch",
},
{
number: 15,
title: "Valid PR title",
url: "https://github.com/pingdotgg/codething-mvp/pull/15",
baseRefName: "main",
headRefName: "feature/status-valid-pr-entry",
},
],
],
},
});
const status = yield* manager.status({ cwd: repoDir });
expect(status.pr).toEqual({
number: 15,
title: "Valid PR title",
url: "https://github.com/pingdotgg/codething-mvp/pull/15",
baseRef: "main",
headRef: "feature/status-valid-pr-entry",
state: "open",
updatedAt: null,
});
}),
);
it.effect("status reports the latest of a branch's closed and merged PRs", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
yield* runGit(repoDir, ["checkout", "-b", "feature/status-lowercase-state"]);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/status-lowercase-state"]);
const { manager } = yield* makeManager({
providerScenario: {
prListSequence: [
[
{
number: 16,
title: "Closed PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/16",
baseRefName: "main",
headRefName: "feature/status-lowercase-state",
state: "closed",
updatedAt: "2026-01-01T00:00:00.000Z",
},
{
number: 17,
title: "Merged PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/17",
baseRefName: "main",
headRefName: "feature/status-lowercase-state",
state: "merged",
updatedAt: "2026-01-02T00:00:00.000Z",
},
],
],
},
});
const status = yield* manager.status({ cwd: repoDir });
expect(status.pr).toEqual({
number: 17,
title: "Merged PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/17",
baseRef: "main",
headRef: "feature/status-lowercase-state",
state: "merged",
updatedAt: "2026-01-02T00:00:00.000Z",
});
}),
);
it.effect("status returns an explicit non-repo result for deleted directories", () =>
Effect.gen(function* () {
const rootDir = yield* makeTempDir("t3code-git-manager-missing-dir-");
const cwd = NodePath.join(rootDir, "deleted-repo");
yield* makeDirectory(cwd);
yield* removePath(cwd);
const { manager } = yield* makeManager();
const status = yield* manager.status({ cwd });
expect(status).toEqual({
isRepo: false,
hasPrimaryRemote: false,
isDefaultRef: false,
refName: null,
hasWorkingTreeChanges: false,
workingTree: {
files: [],
insertions: 0,
deletions: 0,
},
hasUpstream: false,
aheadCount: 0,
behindCount: 0,
aheadOfDefaultCount: 0,
pr: null,
});
}),
);
it.effect("a git read in flight during a T3 git action does not outlive it", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["checkout", "-b", "feature/racing-upstream"]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/racing-upstream"]);
yield* runGit(repoDir, ["push", "origin", "HEAD:refs/heads/feature/raced-head"]);
const pullRequest = (number: number, headRefName: string): FakeChangeRequest[] => [
{
number,
title: headRefName,
url: `https://github.com/pingdotgg/codething-mvp/pull/${number}`,
baseRefName: "main",
headRefName,
state: "open",
updatedAt: "2026-04-07T15:00:00Z",
},
];
const gate = {
matches: (args: ReadonlyArray<string>) =>
args[0] === "for-each-ref" && args.at(-1) === "refs/heads/feature/racing-upstream",
reached: yield* Deferred.make<void>(),
release: yield* Deferred.make<void>(),
};
const { manager } = yield* makeManager({
gitSpawnGate: gate,
providerScenario: {
prListByHeadSelector: {
"feature/racing-upstream": pullRequest(237, "feature/racing-upstream"),
"feature/raced-head": pullRequest(238, "feature/raced-head"),
},
},
});
const lookup = manager.branchPullRequest({
cwd: repoDir,
branch: "feature/racing-upstream",
});
const inFlight = yield* Effect.forkChild(lookup);
yield* Deferred.await(gate.reached);
yield* runGit(repoDir, ["branch", "--set-upstream-to=origin/feature/raced-head"]);
yield* manager.invalidateStatus(repoDir);
yield* Deferred.succeed(gate.release, undefined);
yield* Fiber.join(inFlight);
expect((yield* lookup)?.number).toBe(238);
}),
);
it.effect("branch PR lookup notifies linked threads when draft status changes", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
yield* runGit(repoDir, ["checkout", "-b", "feature/draft-status"]);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/draft-status"]);
const drafts = [false, true, true, false, false, true];
const pullRequest: FakeChangeRequest = {
number: 1,
title: "Draft status",
url: "https://github.com/pingdotgg/codething-mvp/pull/1",
baseRefName: "main",
headRefName: "feature/draft-status",
state: "open",
};
const { manager } = yield* makeManager({
providerScenario: {
prListSequence: [
...drafts.map((isDraft) => [{ ...pullRequest, isDraft }]),
[
{
...pullRequest,
number: 2,
url: "https://github.com/pingdotgg/codething-mvp/pull/2",
state: "merged",
},
],
],
},
});
const changes = yield* manager.subscribePullRequestStateChanges;
for (const isDraft of drafts) {
const pr = yield* manager.branchPullRequest(
{ cwd: repoDir, branch: "feature/draft-status" },
{ refresh: true },
);
expect(pr?.isDraft === true).toBe(isDraft);
}
// A different PR ends collection without waiting on a background stream consumer.
yield* manager.branchPullRequest(
{ cwd: repoDir, branch: "feature/draft-status" },
{ refresh: true },
);
const events = yield* Stream.runCollect(
changes.pipe(Stream.takeUntil((event) => event.number === 2, { excludeLast: true })),
);
expect(events).toEqual([
{ host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
{ host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
{ host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
]);
}),
);
it.effect("a settled branch PR is rechecked only when the branch moves or every 15 minutes", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* runGit(repoDir, ["checkout", "-b", "feature/settled"]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/settled"]);
const pullRequest = (number: number, state: "open" | "merged"): FakeChangeRequest => ({
number,
title: "Settled",
url: `https://github.com/pingdotgg/codething-mvp/pull/${number}`,
baseRefName: "main",
headRefName: "feature/settled",
state,
updatedAt: `2026-04-0${number}T15:00:00Z`,
});
const gitCommands: string[] = [];
const { manager } = yield* makeManager({
gitCommands,
providerScenario: {
prListSequence: [
[pullRequest(1, "merged")],
[pullRequest(1, "merged")],
[pullRequest(1, "merged")],
],
prListOtherwise: [pullRequest(2, "open")],
},
});
const lookup = manager.branchPullRequest({ cwd: repoDir, branch: "feature/settled" });
const freshLookups = () => gitCommands.filter((args) => args === "remote").length;
expect((yield* lookup)?.state).toBe("merged");
gitCommands.length = 0;
expect((yield* lookup)?.state).toBe("merged");
expect((yield* lookup)?.state).toBe("merged");
expect(gitCommands.map((args) => args.split(" ", 1)[0]).toSorted()).toEqual([
"config",
"config",
"for-each-ref",
"for-each-ref",
]);
expect(freshLookups()).toBe(0);
NodeFS.writeFileSync(NodePath.join(repoDir, "settled.txt"), "new work\n");
yield* runGit(repoDir, ["add", "settled.txt"]);
yield* runGit(repoDir, ["commit", "-m", "New work"]);
gitCommands.length = 0;
expect((yield* lookup)?.state).toBe("merged");
expect(freshLookups()).toBe(1);
gitCommands.length = 0;
yield* lookup;
expect(freshLookups()).toBe(0);
// Remembered git state expires after 5 minutes; that rereads git without a recheck.
yield* TestClock.adjust("10 minutes");
gitCommands.length = 0;
expect((yield* lookup)?.state).toBe("merged");
expect(freshLookups()).toBe(1);
yield* TestClock.adjust("5 minutes");
gitCommands.length = 0;
expect((yield* lookup)?.state).toBe("merged");
expect(freshLookups()).toBe(2);
// A new PR from the reused branch shows on the next host query.
yield* TestClock.adjust("5 minutes");
expect((yield* lookup)?.number).toBe(2);
}),
);
it.effect("branch PR lookup uses a saved tracked branch without changing checkout", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* runGit(repoDir, ["checkout", "-b", "feature/saved-branch"]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/saved-branch"]);
yield* runGit(repoDir, ["checkout", "main"]);
const { manager } = yield* makeManager({
providerScenario: {
prListSequence: [
[
{
number: 216,
title: "Saved branch PR",
url: "https://github.com/pingdotgg/t3code/pull/216",
baseRefName: "main",
headRefName: "feature/saved-branch",
headSha: "a".repeat(40),
state: "open",
updatedAt: "2026-04-03T15:00:00Z",
},
],
],
},
});
const pullRequest = yield* manager.branchPullRequest({
cwd: repoDir,
branch: "feature/saved-branch",
});
expect(pullRequest).toMatchObject({
number: 216,
title: "Saved branch PR",
url: "https://github.com/pingdotgg/t3code/pull/216",
baseRef: "main",
headRef: "feature/saved-branch",
headSha: "a".repeat(40),
state: "open",
closedAt: null,
mergedAt: null,
updatedAt: "2026-04-03T15:00:00.000Z",
});
expect((yield* runGit(repoDir, ["branch", "--show-current"])).stdout.trim()).toBe("main");
}),
);
it.effect("branch PR lookup uses the default branch from a non-origin remote", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "upstream", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "upstream", "main"]);
yield* runGit(repoDir, ["checkout", "-b", "develop"]);
yield* runGit(repoDir, ["push", "-u", "upstream", "develop"]);
yield* runGit(remoteDir, ["--git-dir=.", "symbolic-ref", "HEAD", "refs/heads/develop"]);
yield* runGit(repoDir, ["remote", "set-head", "upstream", "develop"]);
const { manager } = yield* makeManager({
providerScenario: {
prListSequence: [
[
{
number: 221,
title: "Merged main PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/221",
baseRefName: "develop",
headRefName: "main",
state: "merged",
mergedAt: "2026-04-07T15:00:00Z",
updatedAt: "2026-04-08T15:00:00Z",
},
],
],
},
});
const pullRequest = yield* manager.branchPullRequest({ cwd: repoDir, branch: "main" });
expect(pullRequest).toMatchObject({
state: "merged",
closedAt: null,
mergedAt: "2026-04-07T15:00:00Z",
updatedAt: "2026-04-08T15:00:00.000Z",
});
}),
);
it.effect("branch PR lookup uses the saved name after the local branch is deleted", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const remoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* runGit(repoDir, ["checkout", "-b", "feature/deleted-local-branch"]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/deleted-local-branch"]);
yield* runGit(repoDir, ["checkout", "main"]);
yield* runGit(repoDir, ["branch", "-D", "feature/deleted-local-branch"]);
yield* runGit(repoDir, ["branch", "feature/deleted-local-branch/child"]);
yield* runGit(repoDir, [
"branch",
"--set-upstream-to",
"origin/main",
"feature/deleted-local-branch/child",
]);
const { manager, providerCalls } = yield* makeManager({
providerScenario: {
prListSequence: [
[
{
number: 217,
title: "Deleted local branch PR",
url: "https://github.com/pingdotgg/t3code/pull/217",
baseRefName: "main",
headRefName: "feature/deleted-local-branch",
state: "merged",
updatedAt: "2026-04-04T15:00:00Z",
},
],
],
},
});
const pullRequest = yield* manager.branchPullRequest({
cwd: repoDir,
branch: "feature/deleted-local-branch",
});
expect(pullRequest).toMatchObject({
state: "merged",
closedAt: null,
mergedAt: null,
updatedAt: "2026-04-04T15:00:00.000Z",
});
expect(listedSelectors(providerCalls).includes("feature/deleted-local-branch")).toBe(true);
}),
);
it.effect("branch PR lookup recovers a deleted fork branch from its remote-tracking ref", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const originDir = yield* createBareRemote();
const forkDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* configureRemote(repoDir, "team/fork", forkDir, "team/fork");
yield* runGit(repoDir, ["checkout", "-b", "feature/deleted-fork-branch"]);
yield* runGit(repoDir, ["push", "-u", "team/fork", "feature/deleted-fork-branch"]);
yield* runGit(repoDir, ["checkout", "main"]);
yield* runGit(repoDir, ["branch", "-D", "feature/deleted-fork-branch"]);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"origin",
"git@github.com:pingdotgg/codething-mvp.git",
originDir,
);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"team/fork",
"git@github.com:contributor/codething-mvp.git",
forkDir,
);
const { manager, providerCalls } = yield* makeManager({
providerScenario: {
prListByHeadSelector: {
"feature/deleted-fork-branch": [
{
number: 218,
title: "Deleted fork branch PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/218",
baseRefName: "main",
headRefName: "feature/deleted-fork-branch",
state: "merged",
updatedAt: "2026-04-05T15:00:00Z",
isCrossRepository: true,
headRepositoryNameWithOwner: "contributor/codething-mvp",
headRepositoryOwnerLogin: "contributor",
},
],
},
},
});
const pullRequest = yield* manager.branchPullRequest({
cwd: repoDir,
branch: "feature/deleted-fork-branch",
});
expect(pullRequest).toMatchObject({
state: "merged",
closedAt: null,
mergedAt: null,
updatedAt: "2026-04-05T15:00:00.000Z",
});
expect(
listed(providerCalls).some(
(call) => call.headSelector === "feature/deleted-fork-branch" && call.state === "all",
),
).toBe(true);
expect(
listedSelectors(providerCalls).some((selector) => selector.startsWith("contributor:")),
).toBe(false);
}),
);
it.effect("branch PR lookup rejects ambiguous deleted-branch remote refs", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const originDir = yield* createBareRemote();
const forkDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
yield* runGit(repoDir, ["checkout", "-b", "feature/ambiguous-remote"]);
yield* runGit(repoDir, ["push", "origin", "feature/ambiguous-remote"]);
yield* runGit(repoDir, ["push", "fork", "feature/ambiguous-remote"]);
yield* runGit(repoDir, ["checkout", "main"]);
yield* runGit(repoDir, ["branch", "-D", "feature/ambiguous-remote"]);
const { manager, providerCalls } = yield* makeManager();
const error = yield* manager
.branchPullRequest({ cwd: repoDir, branch: "feature/ambiguous-remote" })
.pipe(Effect.flip);
expect(error).toMatchObject({
_tag: "GitManagerError",
detail: "Multiple remotes track feature/ambiguous-remote. Its pull request is ambiguous.",
});
expect(providerCalls).toHaveLength(0);
}),
);
it.effect("finds a fork PR for a branch pushed without an upstream", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const originDir = yield* createBareRemote();
const forkDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
yield* runGit(repoDir, ["checkout", "-b", "feature/no-upstream-fork"]);
yield* runGit(repoDir, ["push", "fork", "feature/no-upstream-fork"]);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"origin",
"git@github.com:pingdotgg/codething-mvp.git",
originDir,
);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"fork",
"git@github.com:contributor/codething-mvp.git",
forkDir,
);
const providerScenario: FakeProviderScenario = {
prListByHeadSelector: {
"feature/no-upstream-fork": [
{
number: 40,
title: "Another fork's PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/40",
baseRefName: "main",
headRefName: "feature/no-upstream-fork",
state: "open",
isCrossRepository: true,
headRepositoryNameWithOwner: "someone-else/codething-mvp",
headRepositoryOwnerLogin: "someone-else",
},
{
number: 41,
title: "Our fork's PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/41",
baseRefName: "main",
headRefName: "feature/no-upstream-fork",
state: "open",
isCrossRepository: true,
headRepositoryNameWithOwner: "contributor/codething-mvp",
headRepositoryOwnerLogin: "contributor",
},
],
},
};
const { manager } = yield* makeManager({ providerScenario });
const pullRequest = yield* manager.branchPullRequest({
cwd: repoDir,
branch: "feature/no-upstream-fork",
});
expect(pullRequest?.number).toBe(41);
expect((yield* manager.status({ cwd: repoDir })).pr?.number).toBe(41);
yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Continue feature"]);
const localHead = yield* runGit(repoDir, ["rev-parse", "HEAD"]);
const pushedHead = yield* runGit(repoDir, [
"rev-parse",
"refs/remotes/fork/feature/no-upstream-fork",
]);
expect(localHead.stdout.trim()).not.toBe(pushedHead.stdout.trim());
const { manager: aheadManager } = yield* makeManager({ providerScenario });
expect(
(yield* aheadManager.branchPullRequest({
cwd: repoDir,
branch: "feature/no-upstream-fork",
}))?.number,
).toBe(41);
expect((yield* aheadManager.status({ cwd: repoDir })).pr?.number).toBe(41);
yield* runGit(repoDir, ["config", "branch.feature/no-upstream-fork.remote", "origin"]);
const upstream = yield* runGit(repoDir, [
"for-each-ref",
"--format=%(upstream:short)",
"refs/heads/feature/no-upstream-fork",
]);
expect(upstream.stdout.trim()).toBe("");
const { manager: staleRemoteManager } = yield* makeManager({ providerScenario });
expect(
(yield* staleRemoteManager.branchPullRequest({
cwd: repoDir,
branch: "feature/no-upstream-fork",
}))?.number,
).toBe(41);
yield* runGit(repoDir, ["config", "--unset", "branch.feature/no-upstream-fork.remote"]);
yield* runGit(repoDir, ["checkout", "-b", "diverged-push", "main"]);
yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Rewrite fork head"]);
yield* runGit(repoDir, [
"push",
"--force",
"fork",
"HEAD:refs/heads/feature/no-upstream-fork",
]);
yield* runGit(repoDir, ["checkout", "feature/no-upstream-fork"]);
const { manager: divergedManager } = yield* makeManager({ providerScenario });
expect(
yield* divergedManager.branchPullRequest({
cwd: repoDir,
branch: "feature/no-upstream-fork",
}),
).toBeNull();
}),
);
it.effect("prefers an exact fork ref but does not guess between equal refs", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const originDir = yield* createBareRemote();
const firstForkDir = yield* createBareRemote();
const secondForkDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* runGit(repoDir, ["remote", "add", "first-fork", firstForkDir]);
yield* runGit(repoDir, ["remote", "add", "second-fork", secondForkDir]);
yield* runGit(repoDir, ["checkout", "-b", "feature/ambiguous-fork"]);
yield* runGit(repoDir, ["push", "first-fork", "feature/ambiguous-fork"]);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"origin",
"git@github.com:pingdotgg/codething-mvp.git",
originDir,
);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"first-fork",
"git@github.com:contributor/codething-mvp.git",
firstForkDir,
);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"second-fork",
"git@github.com:someone-else/codething-mvp.git",
secondForkDir,
);
const providerScenario: FakeProviderScenario = {
prListByHeadSelector: {
"feature/ambiguous-fork": [
{
number: 41,
title: "One fork's PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/41",
baseRefName: "main",
headRefName: "feature/ambiguous-fork",
state: "open",
isCrossRepository: true,
headRepositoryNameWithOwner: "contributor/codething-mvp",
headRepositoryOwnerLogin: "contributor",
},
],
},
};
const { manager: singleRemoteManager } = yield* makeManager({ providerScenario });
expect(
(yield* singleRemoteManager.branchPullRequest({
cwd: repoDir,
branch: "feature/ambiguous-fork",
}))?.number,
).toBe(41);
yield* runGit(repoDir, ["push", "second-fork", "feature/ambiguous-fork"]);
const { manager } = yield* makeManager({ providerScenario });
expect(
yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/ambiguous-fork" }),
).toBeNull();
yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Continue feature"]);
yield* runGit(repoDir, ["push", "first-fork", "feature/ambiguous-fork"]);
const { manager: exactManager } = yield* makeManager({ providerScenario });
expect(
(yield* exactManager.branchPullRequest({
cwd: repoDir,
branch: "feature/ambiguous-fork",
}))?.number,
).toBe(41);
}),
);
it.effect("does not guess a fork when an ancestry probe fails", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const originDir = yield* createBareRemote();
const forkDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
yield* runGit(repoDir, ["checkout", "-b", "feature/failed-probe"]);
yield* runGit(repoDir, ["push", "fork", "feature/failed-probe"]);
yield* runGit(repoDir, ["push", "origin", "feature/failed-probe"]);
yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Local work"]);
const treeOid = (yield* runGit(repoDir, ["rev-parse", "HEAD^{tree}"])).stdout.trim();
yield* runGit(repoDir, ["update-ref", "refs/remotes/origin/feature/failed-probe", treeOid]);
const forkProbe = yield* runGit(
repoDir,
["merge-base", "--is-ancestor", "refs/remotes/fork/feature/failed-probe", "HEAD"],
true,
);
expect(forkProbe.exitCode).toBe(0);
const originProbe = yield* runGit(
repoDir,
["merge-base", "--is-ancestor", "refs/remotes/origin/feature/failed-probe", "HEAD"],
true,
);
expect(originProbe.exitCode).not.toBe(0);
expect(originProbe.exitCode).not.toBe(1);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"origin",
"git@github.com:pingdotgg/codething-mvp.git",
originDir,
);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"fork",
"git@github.com:contributor/codething-mvp.git",
forkDir,
);
const providerScenario: FakeProviderScenario = {
prListByHeadSelector: {
"feature/failed-probe": [
{
number: 43,
title: "Failed probe PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/43",
baseRefName: "main",
headRefName: "feature/failed-probe",
state: "open",
isCrossRepository: true,
headRepositoryNameWithOwner: "contributor/codething-mvp",
headRepositoryOwnerLogin: "contributor",
},
],
},
};
const { manager } = yield* makeManager({ providerScenario });
expect(
yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/failed-probe" }),
).toBeNull();
}),
);
it.effect("finds a fork PR when the remote name contains a slash", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const originDir = yield* createBareRemote();
const forkDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
yield* runGit(repoDir, ["remote", "add", "team/fork", forkDir]);
yield* runGit(repoDir, ["checkout", "-b", "feature/slash-remote"]);
yield* runGit(repoDir, ["push", "team/fork", "feature/slash-remote"]);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"origin",
"git@github.com:pingdotgg/codething-mvp.git",
originDir,
);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"team/fork",
"git@github.com:contributor/codething-mvp.git",
forkDir,
);
const { manager } = yield* makeManager({
providerScenario: {
prListByHeadSelector: {
"feature/slash-remote": [
{
number: 42,
title: "Slash remote PR",
url: "https://github.com/pingdotgg/codething-mvp/pull/42",
baseRefName: "main",
headRefName: "feature/slash-remote",
state: "open",
isCrossRepository: true,
headRepositoryNameWithOwner: "contributor/codething-mvp",
headRepositoryOwnerLogin: "contributor",
},
],
},
},
});
expect(
(yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/slash-remote" }))
?.number,
).toBe(42);
}),
);
it.effect("branch PR lookup does not reuse a cached PR after the remote is repointed", () =>
Effect.gen(function* () {
const repoDir = yield* makeTempDir("t3code-git-manager-");
yield* initRepo(repoDir);
const originalRemoteDir = yield* createBareRemote();
yield* runGit(repoDir, ["remote", "add", "origin", originalRemoteDir]);
yield* runGit(repoDir, ["checkout", "-b", "feature/repointed-lookup"]);
yield* runGit(repoDir, ["push", "-u", "origin", "feature/repointed-lookup"]);
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"origin",
"git@github.com:old-owner/old-repository.git",
originalRemoteDir,
);
const { manager, providerCalls } = yield* makeManager({
providerScenario: {
prListSequence: [
[
{
number: 219,
title: "Old repository PR",
url: "https://github.com/old-owner/old-repository/pull/219",
baseRefName: "main",
headRefName: "feature/repointed-lookup",
state: "merged",
updatedAt: "2026-04-06T15:00:00Z",
},
],
[],
],
},
});
const first = yield* manager.branchPullRequest({
cwd: repoDir,
branch: "feature/repointed-lookup",
});
expect(first?.state).toBe("merged");
const replacementRemoteDir = yield* createBareRemote();
yield* configureVisibleRemoteUrlWithLocalRewrite(
repoDir,
"origin",
"git@github.com:new-owner/new-repository.git",
replacementRemoteDir,
);
const second = yield* manager.branchPullRequest({
cwd: repoDir,
branch: "feature/repointed-lookup",
});
expect(second).toBeNull();
expect(listed(providerCalls)).toHaveLength(2);
}),
);
// regression: #8600 settle threads server-side
it.effect("branch PR lookup propagates provider failures", () =>