The best way to control Claude Code, Codex and more from any computer or phone

main
ts 7,056 lines 275 KB
Raw
1 import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
2 import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
3 import { type PullRequestActionInput, SourceControlProviderKind } from "@t3tools/contracts";
4 // @effect-diagnostics nodeBuiltinImport:off
5 import * as NodeFS from "node:fs";
6 import * as NodePath from "node:path";
7 import * as NodeChildProcess from "node:child_process";
8
9 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
10 import * as NodeServices from "@effect/platform-node/NodeServices";
11 import { it } from "@effect/vitest";
12 import * as Context from "effect/Context";
13 import * as Effect from "effect/Effect";
14 import * as Deferred from "effect/Deferred";
15 import * as Fiber from "effect/Fiber";
16 import * as FileSystem from "effect/FileSystem";
17 import * as Layer from "effect/Layer";
18 import * as Option from "effect/Option";
19 import * as PlatformError from "effect/PlatformError";
20 import * as Result from "effect/Result";
21 import * as Scope from "effect/Scope";
22 import * as Stream from "effect/Stream";
23 import * as TestClock from "effect/testing/TestClock";
24 import * as HostProcess from "@t3tools/shared/HostProcess";
25 import { ChildProcessSpawner } from "effect/process";
26 import { expect } from "vite-plus/test";
27 import type {
28 ChangeRequest,
29 GitActionProgressEvent,
30 GitPreparePullRequestThreadInput,
31 ModelSelection,
32 } from "@t3tools/contracts";
33
34 import {
35 DEFAULT_SERVER_SETTINGS,
36 EventId,
37 GitCommandError,
38 MessageId,
39 ProjectId,
40 ProviderDriverKind,
41 ProviderInstanceId,
42 RunId,
43 SourceControlProviderError as SourceControlProviderFailure,
44 TextGenerationError,
45 ThreadId,
46 TurnItemId,
47 } from "@t3tools/contracts";
48 import * as DateTime from "effect/DateTime";
49 import * as TextGeneration from "../textGeneration/TextGeneration.ts";
50 import {
51 fromRunner,
52 decodeJsonReply,
53 } from "@t3tools/provider-core/server/textGenerationOperations";
54 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
55 import * as VcsProcess from "../vcs/VcsProcess.ts";
56 import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
57 import * as VcsProjectConfig from "../vcs/VcsProjectConfig.ts";
58 import * as GitWorkflowService from "./GitWorkflowService.ts";
59 import type {
60 SourceControlProvider,
61 SourceControlRefSelector,
62 } from "@t3tools/source-control-core/server/SourceControlProvider";
63 import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
64 import * as ServerConfig from "../config.ts";
65 import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
66 import * as ProjectStore from "../orchestration-v2/ProjectStore.ts";
67 import * as PullRequestService from "../pullRequest/PullRequestService.ts";
68 import * as SqlitePersistence from "../persistence/Sqlite.ts";
69 import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
70 import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
71 import * as ServerSettings from "../serverSettings.ts";
72 import * as GitManager from "./GitManager.ts";
73
74 /** A change request the fake host reports. Omitted fields read as an open, undated request. */
75 type FakeChangeRequest = Omit<ChangeRequest, "provider" | "state" | "updatedAt"> & {
76 readonly state?: ChangeRequest["state"];
77 readonly updatedAt?: string;
78 };
79
80 interface FakeProviderScenario {
81 prListGate?: {
82 readonly started: Deferred.Deferred<void>;
83 readonly release: Deferred.Deferred<void>;
84 };
85 /** The kind the fake host reports itself as. */
86 kind?: string;
87 /** False for a host that opens every change request ready for review. */
88 createsDraftChangeRequests?: boolean;
89 /** Answers to successive change request listings, whatever their head selector. */
90 prListSequence?: ReadonlyArray<ReadonlyArray<FakeChangeRequest>>;
91 prListByHeadSelector?: Record<string, ReadonlyArray<FakeChangeRequest>>;
92 prListSequenceByHeadSelector?: Record<string, ReadonlyArray<ReadonlyArray<FakeChangeRequest>>>;
93 /** The answer to every listing the other lists leave unanswered. */
94 prListOtherwise?: ReadonlyArray<FakeChangeRequest>;
95 defaultBranch?: string;
96 pullRequest?: FakeChangeRequest;
97 repositoryCloneUrls?: Record<string, { url: string; sshUrl: string }>;
98 failWith?: string;
99 failCause?: unknown;
100 failAfterCalls?: number;
101 /** Check out the pull request head from its pull ref: fast-forward only unless forced. */
102 syncCheckoutWithPullHead?: boolean;
103 /**
104 * The host's `headBranchProbe`. By default the fake probes bare branch names, a hundred at a
105 * time, or only the owner-qualified default branch, as GitHub does, so tests see GitManager
106 * defer to the hook; null leaves the probe to GitManager.
107 */
108 headBranchProbe?: SourceControlProvider["Service"]["headBranchProbe"] | null;
109 }
110
111 type FakeProviderCall =
112 | {
113 readonly operation: "listChangeRequests";
114 readonly headSelector: string;
115 readonly state: string;
116 readonly limit: number | undefined;
117 }
118 | {
119 readonly operation: "createChangeRequest";
120 readonly source: SourceControlRefSelector | undefined;
121 readonly baseRefName: string;
122 readonly headSelector: string;
123 readonly title: string;
124 readonly draft: unknown;
125 }
126 | { readonly operation: "getChangeRequest"; readonly reference: string }
127 | {
128 readonly operation: "checkoutChangeRequest";
129 readonly reference: string;
130 readonly force: boolean;
131 }
132 | { readonly operation: "getRepositoryCloneUrls"; readonly repository: string }
133 | { readonly operation: "getDefaultBranch" };
134
135 const listed = (calls: ReadonlyArray<FakeProviderCall>) =>
136 calls.flatMap((call) => (call.operation === "listChangeRequests" ? [call] : []));
137
138 const listedSelectors = (calls: ReadonlyArray<FakeProviderCall>) =>
139 listed(calls).map((call) => call.headSelector);
140
141 const created = (calls: ReadonlyArray<FakeProviderCall>) =>
142 calls.flatMap((call) =>
143 call.operation === "createChangeRequest"
144 ? [{ baseRefName: call.baseRefName, headSelector: call.headSelector }]
145 : [],
146 );
147
148 type FakeGitTextGeneration = TextGeneration.TextGeneration["Service"];
149
150 function runGitSyncForFakeCheckout(cwd: string, args: readonly string[]): void {
151 const result = NodeChildProcess.spawnSync("git", args, {
152 cwd,
153 encoding: "utf8",
154 });
155 if (result.status === 0) {
156 return;
157 }
158 throw new Error(
159 `Failed to simulate a host checkout with git ${args.join(" ")}: ${result.stderr?.trim() || "unknown error"}`,
160 );
161 }
162 function makeTempDir(
163 prefix: string,
164 ): Effect.Effect<string, PlatformError.PlatformError, FileSystem.FileSystem | Scope.Scope> {
165 return Effect.gen(function* () {
166 const fileSystem = yield* FileSystem.FileSystem;
167 return yield* fileSystem.makeTempDirectoryScoped({ prefix });
168 });
169 }
170
171 function removePath(
172 targetPath: string,
173 ): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem> {
174 return Effect.gen(function* () {
175 const fileSystem = yield* FileSystem.FileSystem;
176 yield* fileSystem.remove(targetPath, { recursive: true, force: true });
177 });
178 }
179
180 function makeDirectory(
181 dirPath: string,
182 ): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem> {
183 return Effect.gen(function* () {
184 const fileSystem = yield* FileSystem.FileSystem;
185 yield* fileSystem.makeDirectory(dirPath, { recursive: true });
186 });
187 }
188
189 function runGit(
190 cwd: string,
191 args: readonly string[],
192 allowNonZeroExit = false,
193 ): Effect.Effect<
194 {
195 readonly exitCode: GitVcsDriver.ExecuteGitResult["exitCode"];
196 readonly stdout: string;
197 readonly stderr: string;
198 },
199 GitCommandError,
200 GitVcsDriver.GitVcsDriver
201 > {
202 return Effect.gen(function* () {
203 const git = yield* GitVcsDriver.GitVcsDriver;
204 const result = yield* git.execute({
205 operation: "GitManager.test.runGit",
206 cwd,
207 args,
208 allowNonZeroExit,
209 });
210 return {
211 exitCode: result.exitCode,
212 stdout: result.stdout,
213 stderr: result.stderr,
214 };
215 });
216 }
217
218 /** A committed repository and an empty bare remote, built once and copied into each test. */
219 class GitFixtureTemplates extends Context.Service<
220 GitFixtureTemplates,
221 { readonly repo: string; readonly bareRemote: string }
222 >()("t3/git/GitManager.test/GitFixtureTemplates") {}
223
224 const layerGitFixtureTemplates = Layer.effect(
225 GitFixtureTemplates,
226 Effect.gen(function* () {
227 const fs = yield* FileSystem.FileSystem;
228 const repo = yield* makeTempDir("t3code-git-template-");
229 // An empty template skips copying git's sample hooks into every test repository.
230 yield* runGit(repo, ["init", "--initial-branch=main", "--template="]);
231 yield* runGit(repo, ["config", "user.email", "test@example.com"]);
232 yield* runGit(repo, ["config", "user.name", "Test User"]);
233 // Override global autocrlf on Windows for LF assertions, including linked worktrees.
234 yield* runGit(repo, ["config", "core.autocrlf", "false"]);
235 yield* fs.writeFileString(NodePath.join(repo, "README.md"), "hello\n");
236 yield* runGit(repo, ["add", "README.md"]);
237 yield* runGit(repo, ["commit", "-m", "Initial commit"]);
238 const bareRemote = yield* makeTempDir("t3code-git-remote-template-");
239 yield* runGit(bareRemote, ["init", "--bare", "--template="]);
240 yield* fs.makeDirectory(NodePath.join(bareRemote, "hooks"), { recursive: true });
241 return { repo, bareRemote };
242 }),
243 );
244
245 function initRepo(
246 cwd: string,
247 ): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem | GitFixtureTemplates> {
248 return Effect.gen(function* () {
249 const fs = yield* FileSystem.FileSystem;
250 const templates = yield* GitFixtureTemplates;
251 for (const entry of [".git", "README.md"]) {
252 yield* fs.copy(NodePath.join(templates.repo, entry), NodePath.join(cwd, entry));
253 }
254 });
255 }
256
257 function createBareRemote(): Effect.Effect<
258 string,
259 PlatformError.PlatformError,
260 FileSystem.FileSystem | Scope.Scope | GitFixtureTemplates
261 > {
262 return Effect.gen(function* () {
263 const fs = yield* FileSystem.FileSystem;
264 const templates = yield* GitFixtureTemplates;
265 const remoteDir = yield* makeTempDir("t3code-git-remote-");
266 yield* fs.copy(templates.bareRemote, remoteDir, { overwrite: true });
267 return remoteDir;
268 });
269 }
270
271 function configureRemote(
272 cwd: string,
273 remoteName: string,
274 remotePath: string,
275 fetchNamespace: string,
276 ): Effect.Effect<void, GitCommandError, GitVcsDriver.GitVcsDriver> {
277 return Effect.gen(function* () {
278 yield* runGit(cwd, ["config", `remote.${remoteName}.url`, remotePath]);
279 yield* runGit(cwd, [
280 "config",
281 "--replace-all",
282 `remote.${remoteName}.fetch`,
283 `+refs/heads/*:refs/remotes/${fetchNamespace}/*`,
284 ]);
285 });
286 }
287
288 function configureVisibleRemoteUrlWithLocalRewrite(
289 cwd: string,
290 remoteName: string,
291 visibleUrl: string,
292 localRemotePath: string,
293 ): Effect.Effect<void, GitCommandError, GitVcsDriver.GitVcsDriver> {
294 return Effect.gen(function* () {
295 yield* runGit(cwd, ["config", `remote.${remoteName}.url`, visibleUrl]);
296 yield* runGit(cwd, ["config", `url.${localRemotePath}.insteadOf`, visibleUrl]);
297 });
298 }
299
300 function createTextGeneration(
301 overrides: Partial<FakeGitTextGeneration> = {},
302 ): TextGeneration.TextGeneration["Service"] {
303 const implementation: FakeGitTextGeneration = {
304 generateCommitMessage: (input) =>
305 Effect.succeed({
306 subject: "Implement stacked git actions",
307 body: "",
308 ...(input.includeBranch ? { branch: "feature/implement-stacked-git-actions" } : {}),
309 }),
310 generatePrContent: () =>
311 Effect.succeed({
312 title: "Add stacked git actions",
313 body: "## Summary\n- Add stacked git workflow\n\n## Testing\n- Not run",
314 }),
315 generateBranchName: () =>
316 Effect.succeed({
317 branch: "update-workflow",
318 }),
319 generateThreadTitle: () =>
320 Effect.succeed({
321 title: "Update workflow",
322 }),
323 generateReviewGuide: () => Effect.succeed({ stops: [] }),
324 generateTranscriptionPostProcessing: () =>
325 Effect.succeed({ transcription: "processed transcript" }),
326 ...overrides,
327 };
328
329 return {
330 generateCommitMessage: (input) =>
331 implementation.generateCommitMessage(input).pipe(
332 Effect.mapError(
333 (cause) =>
334 new TextGenerationError({
335 operation: "generateCommitMessage",
336 detail: "fake text generation failed",
337 ...(cause !== undefined ? { cause } : {}),
338 }),
339 ),
340 ),
341 generatePrContent: (input) =>
342 implementation.generatePrContent(input).pipe(
343 Effect.mapError(
344 (cause) =>
345 new TextGenerationError({
346 operation: "generatePrContent",
347 detail: "fake text generation failed",
348 ...(cause !== undefined ? { cause } : {}),
349 }),
350 ),
351 ),
352 generateBranchName: (input) =>
353 implementation.generateBranchName(input).pipe(
354 Effect.mapError(
355 (cause) =>
356 new TextGenerationError({
357 operation: "generateBranchName",
358 detail: "fake text generation failed",
359 ...(cause !== undefined ? { cause } : {}),
360 }),
361 ),
362 ),
363 generateThreadTitle: (input) =>
364 implementation.generateThreadTitle(input).pipe(
365 Effect.mapError(
366 (cause) =>
367 new TextGenerationError({
368 operation: "generateThreadTitle",
369 detail: "fake text generation failed",
370 ...(cause !== undefined ? { cause } : {}),
371 }),
372 ),
373 ),
374 generateReviewGuide: (input) => implementation.generateReviewGuide(input),
375 generateTranscriptionPostProcessing: (input) =>
376 implementation.generateTranscriptionPostProcessing(input),
377 };
378 }
379
380 /**
381 * A host that answers from the scenario and records what it was asked, so tests assert on the
382 * selectors GitManager chose rather than on any host's wire format.
383 */
384 function createFakeSourceControlProvider(scenario: FakeProviderScenario = {}): {
385 service: SourceControlProvider["Service"];
386 calls: FakeProviderCall[];
387 } {
388 const kind = SourceControlProviderKind.make(scenario.kind ?? "github");
389 const prListQueue = [...(scenario.prListSequence ?? [])];
390 const prListQueueByHeadSelector = new Map(
391 Object.entries(scenario.prListSequenceByHeadSelector ?? {}).map(([headSelector, values]) => [
392 headSelector,
393 [...values],
394 ]),
395 );
396 const calls: FakeProviderCall[] = [];
397
398 const record = (cwd: string, call: FakeProviderCall) =>
399 Effect.suspend(() => {
400 calls.push(call);
401 return scenario.failWith && calls.length > (scenario.failAfterCalls ?? 0)
402 ? Effect.fail(
403 new SourceControlProviderFailure({
404 provider: kind,
405 operation: call.operation,
406 cwd,
407 detail: scenario.failWith,
408 cause: scenario.failCause,
409 }),
410 )
411 : Effect.void;
412 });
413
414 const toChangeRequest = (summary: FakeChangeRequest): ChangeRequest => ({
415 ...summary,
416 provider: kind,
417 state: summary.state ?? "open",
418 closedAt: summary.closedAt ?? null,
419 mergedAt: summary.mergedAt ?? null,
420 updatedAt:
421 summary.updatedAt === undefined
422 ? Option.none()
423 : Option.some(DateTime.makeUnsafe(summary.updatedAt)),
424 });
425
426 const pullRequest = (): FakeChangeRequest =>
427 scenario.pullRequest ?? {
428 number: 101,
429 title: "Pull request",
430 url: "https://github.com/pingdotgg/codething-mvp/pull/101",
431 baseRefName: "main",
432 headRefName: "feature/pull-request",
433 state: "open",
434 };
435
436 const checkout = (cwd: string, force: boolean) => {
437 const headBranch = scenario.pullRequest?.headRefName;
438 if (!headBranch) return;
439 const existingBranch = NodeChildProcess.spawnSync(
440 "git",
441 ["show-ref", "--verify", "--quiet", `refs/heads/${headBranch}`],
442 { cwd },
443 );
444 if (scenario.syncCheckoutWithPullHead) {
445 runGitSyncForFakeCheckout(cwd, [
446 "fetch",
447 "origin",
448 `refs/pull/${scenario.pullRequest?.number}/head`,
449 ]);
450 if (existingBranch.status === 0) {
451 runGitSyncForFakeCheckout(cwd, ["checkout", headBranch]);
452 runGitSyncForFakeCheckout(
453 cwd,
454 force ? ["reset", "--hard", "FETCH_HEAD"] : ["merge", "--ff-only", "FETCH_HEAD"],
455 );
456 } else {
457 runGitSyncForFakeCheckout(cwd, ["checkout", "-b", headBranch, "FETCH_HEAD"]);
458 }
459 } else if (existingBranch.status === 0) {
460 runGitSyncForFakeCheckout(cwd, ["checkout", headBranch]);
461 } else {
462 runGitSyncForFakeCheckout(cwd, ["checkout", "-b", headBranch]);
463 }
464 };
465
466 const headBranchProbe =
467 scenario.headBranchProbe === null
468 ? {}
469 : {
470 headBranchProbe:
471 scenario.headBranchProbe ??
472 (({ headSelectors, ownerHeadSelector }) => ({
473 headSelectors: ownerHeadSelector
474 ? [ownerHeadSelector]
475 : headSelectors.filter((selector) => !selector.includes(":")),
476 limit: 100,
477 })),
478 };
479
480 return {
481 service: {
482 kind,
483 createsDraftChangeRequests: scenario.createsDraftChangeRequests ?? true,
484 ...headBranchProbe,
485 listChangeRequests: (input) =>
486 record(input.cwd, {
487 operation: "listChangeRequests",
488 headSelector: input.headSelector,
489 state: input.state,
490 limit: input.limit,
491 }).pipe(
492 Effect.map(() =>
493 (
494 prListQueueByHeadSelector.get(input.headSelector)?.shift() ??
495 scenario.prListByHeadSelector?.[input.headSelector] ??
496 prListQueue.shift() ??
497 scenario.prListOtherwise ??
498 []
499 ).map(toChangeRequest),
500 ),
501 Effect.tap(() =>
502 scenario.prListGate
503 ? Deferred.succeed(scenario.prListGate.started, undefined).pipe(
504 Effect.andThen(Deferred.await(scenario.prListGate.release)),
505 )
506 : Effect.void,
507 ),
508 ),
509 createChangeRequest: (input) =>
510 record(input.cwd, {
511 operation: "createChangeRequest",
512 source: input.source,
513 baseRefName: input.baseRefName,
514 headSelector: input.headSelector,
515 title: input.title,
516 draft: "draft" in input ? input.draft : undefined,
517 }),
518 getDefaultBranch: (input) =>
519 record(input.cwd, { operation: "getDefaultBranch" }).pipe(
520 Effect.map(() => {
521 const value = (scenario.defaultBranch ?? "main").trim();
522 return value.length > 0 ? value : null;
523 }),
524 ),
525 getChangeRequest: (input) =>
526 record(input.cwd, { operation: "getChangeRequest", reference: input.reference }).pipe(
527 Effect.map(() => toChangeRequest(pullRequest())),
528 ),
529 getRepositoryCloneUrls: (input) =>
530 record(input.cwd, {
531 operation: "getRepositoryCloneUrls",
532 repository: input.repository,
533 }).pipe(
534 Effect.flatMap(() => {
535 const repository = input.host ? `${input.host}/${input.repository}` : input.repository;
536 const cloneUrls =
537 scenario.repositoryCloneUrls?.[repository] ??
538 (input.host === "github.com"
539 ? scenario.repositoryCloneUrls?.[input.repository]
540 : undefined);
541 return cloneUrls
542 ? Effect.succeed({ nameWithOwner: input.repository, ...cloneUrls })
543 : Effect.fail(
544 new SourceControlProviderFailure({
545 provider: kind,
546 operation: "getRepositoryCloneUrls",
547 cwd: input.cwd,
548 detail: `Unexpected repository lookup: ${input.repository}`,
549 }),
550 );
551 }),
552 ),
553 createRepository: (input) =>
554 Effect.fail(
555 new SourceControlProviderFailure({
556 provider: kind,
557 operation: "createRepository",
558 cwd: input.cwd,
559 detail: `Unexpected repository create: ${input.repository}`,
560 }),
561 ),
562 checkoutChangeRequest: (input) =>
563 record(input.cwd, {
564 operation: "checkoutChangeRequest",
565 reference: input.reference,
566 force: input.force ?? false,
567 }).pipe(
568 Effect.flatMap(() =>
569 Effect.try({
570 try: () => checkout(input.cwd, input.force ?? false),
571 catch: (cause) =>
572 new SourceControlProviderFailure({
573 provider: kind,
574 operation: "checkoutChangeRequest",
575 cwd: input.cwd,
576 detail: "Host checkout failed.",
577 cause,
578 }),
579 }),
580 ),
581 ),
582 },
583 calls,
584 };
585 }
586
587 /**
588 * Reads a template from the base tree the way a host would, without any host's own lookup
589 * rules, so tests see which tree GitManager reads it from.
590 */
591 const readFakeChangeRequestTemplate = Effect.fnUntraced(function* (input: {
592 readonly cwd: string;
593 readonly treeish: string;
594 }) {
595 const git = yield* GitVcsDriver.GitVcsDriver;
596 const result = yield* git
597 .execute({
598 operation: "GitManager.test.readTemplate",
599 cwd: input.cwd,
600 args: ["show", `${input.treeish}:.github/pull_request_template.md`],
601 allowNonZeroExit: true,
602 })
603 .pipe(Effect.orDie);
604 const template = result.stdout.trim();
605 return result.exitCode === 0 && template.length > 0 ? Option.some(template) : Option.none();
606 });
607 function runStackedAction(
608 manager: GitManager.GitManager["Service"],
609 input: {
610 cwd: string;
611 action: "commit" | "push" | "create_pr" | "commit_push" | "commit_push_pr";
612 actionId?: string;
613 commitMessage?: string;
614 featureBranch?: boolean;
615 filePaths?: readonly string[];
616 },
617 options?: Parameters<GitManager.GitManager["Service"]["runStackedAction"]>[1],
618 ) {
619 return manager.runStackedAction(
620 {
621 ...input,
622 actionId: input.actionId ?? "test-action-id",
623 },
624 options,
625 );
626 }
627
628 function preparePullRequestThread(
629 manager: GitManager.GitManager["Service"],
630 input: GitPreparePullRequestThreadInput,
631 ) {
632 return manager.preparePullRequestThread(input);
633 }
634
635 function makeManager(input?: {
636 providerScenario?: FakeProviderScenario;
637 pullRequests?: Partial<PullRequestService.PullRequestService["Service"]>;
638 sourceControlProvider?: SourceControlProvider["Service"];
639 textGeneration?: Partial<FakeGitTextGeneration>;
640 serverSettings?: Parameters<typeof ServerSettings.layerTest>[0];
641 setupScriptRunner?: ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"];
642 gitConfigReads?: string[];
643 gitCommands?: string[];
644 gitSpawnGate?: {
645 readonly matches: (args: ReadonlyArray<string>) => boolean;
646 readonly reached: Deferred.Deferred<void>;
647 readonly release: Deferred.Deferred<void>;
648 };
649 seed?: Effect.Effect<
650 void,
651 ProjectionStore.ProjectionStoreV2Error | ProjectStore.ProjectStoreV2Error,
652 ProjectionStore.ProjectionStoreV2 | ProjectStore.ProjectStoreV2
653 >;
654 }) {
655 const { service: fakeProvider, calls: providerCalls } = createFakeSourceControlProvider(
656 input?.providerScenario,
657 );
658 const textGeneration = createTextGeneration(input?.textGeneration);
659 const layerServerConfig = ServerConfig.layerTest(process.cwd(), {
660 prefix: "t3-git-manager-test-",
661 });
662
663 const layerServerSettings = ServerSettings.ServerSettingsService.layerTest(input?.serverSettings);
664
665 const gitCommands = input?.gitCommands;
666 const gitSpawnGate = input?.gitSpawnGate;
667 const watchesGitSpawns = gitCommands !== undefined || gitSpawnGate !== undefined;
668 const layerGitDriverSpawner = watchesGitSpawns
669 ? Layer.effect(
670 ChildProcessSpawner.ChildProcessSpawner,
671 Effect.gen(function* () {
672 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
673 return ChildProcessSpawner.make((command) => {
674 // On Windows the driver starts git by its full path to git.exe.
675 const args =
676 command._tag === "StandardCommand" &&
677 NodePath.parse(command.command).name.toLowerCase() === "git"
678 ? command.args.map(String)
679 : null;
680 if (args !== null) gitCommands?.push(args.join(" "));
681 if (args === null || gitSpawnGate === undefined || !gitSpawnGate.matches(args)) {
682 return spawner.spawn(command);
683 }
684 return spawner
685 .spawn(command)
686 .pipe(
687 Effect.tap((handle) =>
688 handle.exitCode.pipe(
689 Effect.andThen(Deferred.succeed(gitSpawnGate.reached, undefined)),
690 Effect.andThen(Deferred.await(gitSpawnGate.release)),
691 ),
692 ),
693 );
694 });
695 }),
696 ).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)))
697 : Layer.empty;
698 const gitVcsDriver = input?.gitConfigReads
699 ? Layer.effect(
700 GitVcsDriver.GitVcsDriver,
701 GitVcsDriver.make.pipe(
702 Effect.map((service) =>
703 GitVcsDriver.GitVcsDriver.of({
704 ...service,
705 readConfigValue: (cwd, key) =>
706 Effect.sync(() => input.gitConfigReads?.push(key)).pipe(
707 Effect.andThen(service.readConfigValue(cwd, key)),
708 ),
709 }),
710 ),
711 ),
712 )
713 : GitVcsDriver.layer;
714 const layerVcsDriver = (watchesGitSpawns ? Layer.fresh(gitVcsDriver) : gitVcsDriver).pipe(
715 Layer.provide(layerGitDriverSpawner),
716 Layer.provideMerge(VcsProcess.layer),
717 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
718 Layer.provideMerge(layerServerConfig),
719 );
720 const layerSourceControlRegistry = Layer.effect(
721 SourceControlProviderRegistry.SourceControlProviderRegistry,
722 Effect.gen(function* () {
723 const context = yield* Effect.context<GitVcsDriver.GitVcsDriver>();
724 return (
725 input?.sourceControlProvider ?? {
726 ...fakeProvider,
727 readChangeRequestTemplate: (template: { cwd: string; treeish: string }) =>
728 readFakeChangeRequestTemplate(template).pipe(Effect.provideContext(context)),
729 }
730 );
731 }).pipe(
732 Effect.map((provider) =>
733 SourceControlProviderRegistry.SourceControlProviderRegistry.of({
734 resolveLink: (input) => provider.resolveLink?.(input),
735 get: () => Effect.succeed(provider),
736 resolveHandle: () => Effect.succeed({ provider, context: null }),
737 resolve: () => Effect.succeed(provider),
738 discover: Effect.succeed([]),
739 }),
740 ),
741 ),
742 );
743
744 const layerManager = Layer.mergeAll(
745 Layer.succeed(TextGeneration.TextGeneration, textGeneration),
746 Layer.mock(PullRequestService.PullRequestService)(input?.pullRequests ?? {}),
747 Layer.mock(ProviderRegistry.ProviderRegistry)({
748 getProviders: Effect.succeed([]),
749 }),
750 Layer.succeed(
751 ProjectSetupScriptRunner.ProjectSetupScriptRunner,
752 input?.setupScriptRunner ?? {
753 runForThread: () => Effect.succeed({ status: "no-script" as const }),
754 },
755 ),
756 layerServerSettings,
757 ).pipe(
758 Layer.provideMerge(layerSourceControlRegistry),
759 Layer.provideMerge(layerVcsDriver),
760 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
761 );
762 const layerStores = Layer.merge(ProjectionStore.layer, ProjectStore.layer).pipe(
763 Layer.provideMerge(SqlitePersistence.layerMemory),
764 );
765
766 return Effect.gen(function* () {
767 const stores = yield* Layer.build(layerStores);
768 if (input?.seed !== undefined) {
769 yield* input.seed.pipe(Effect.provideContext(stores), Effect.orDie);
770 }
771 const manager = yield* GitManager.make.pipe(
772 Effect.provide(layerManager),
773 Effect.provideContext(stores),
774 );
775 return { manager, providerCalls };
776 });
777 }
778
779 const asThreadId = (threadId: string) => threadId as ThreadId;
780
781 const layerGitManagerTest = layerGitFixtureTemplates.pipe(
782 Layer.provideMerge(GitVcsDriver.layer),
783 Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-git-manager-test-" })),
784 Layer.provideMerge(VcsProcess.layer),
785 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
786 );
787
788 it.layer(layerGitManagerTest)("GitManager", (it) => {
789 it.effect(
790 "publishes local Git changes during a held PR lookup without caching its old branch",
791 () =>
792 Effect.gen(function* () {
793 const repoDir = yield* makeTempDir("t3code-refresh-status-gh-gate-");
794 yield* initRepo(repoDir);
795 yield* runGit(repoDir, ["checkout", "-b", "release"]);
796 const remoteDir = yield* createBareRemote();
797 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
798 yield* runGit(repoDir, ["push", "-u", "origin", "release"]);
799 yield* runGit(repoDir, ["tag", "release"]);
800 const oldPr = {
801 number: 613,
802 title: "Release PR",
803 url: "https://github.com/pingdotgg/codething-mvp/pull/613",
804 baseRefName: "main",
805 headRefName: "release",
806 };
807 const newPr = { ...oldPr, number: 614, headRefName: "heads/release" };
808 const providerScenario: FakeProviderScenario = {
809 prListSequence: [oldPr, oldPr, newPr].map((pr) => [pr]),
810 };
811 const { manager } = yield* makeManager({ providerScenario });
812 const context = yield* Layer.build(
813 VcsStatusBroadcaster.layer.pipe(
814 Layer.provide(
815 GitWorkflowService.layer.pipe(
816 Layer.provide(Layer.succeed(GitManager.GitManager, manager)),
817 Layer.provide(
818 VcsDriverRegistry.layer.pipe(
819 Layer.provide(VcsProjectConfig.layer),
820 Layer.provide(VcsProcess.layer),
821 ),
822 ),
823 ),
824 ),
825 Layer.provide(
826 Layer.mock(BackgroundPolicy.BackgroundPolicy)({
827 shouldRunScopeWork: () => Effect.succeed(true),
828 }),
829 ),
830 ),
831 );
832 const broadcaster = Context.get(context, VcsStatusBroadcaster.VcsStatusBroadcaster);
833 const initial = yield* broadcaster.getStatus({ cwd: repoDir });
834 expect(initial.refName).toBe("release");
835 expect(initial.pr?.number).toBe(613);
836
837 const subscribed = yield* Deferred.make<void>();
838 const published = yield* Deferred.make<void>();
839 yield* broadcaster.streamStatus({ cwd: repoDir, includeRemote: false }).pipe(
840 Stream.runForEach((event) => {
841 if (event._tag === "snapshot") return Deferred.succeed(subscribed, undefined);
842 if (event._tag === "localUpdated" && event.local.hasWorkingTreeChanges) {
843 return Deferred.succeed(published, undefined);
844 }
845 return Effect.void;
846 }),
847 Effect.forkScoped,
848 );
849 yield* Deferred.await(subscribed);
850 const gate = {
851 started: yield* Deferred.make<void>(),
852 release: yield* Deferred.make<void>(),
853 };
854 providerScenario.prListGate = gate;
855 const fs = yield* FileSystem.FileSystem;
856 yield* fs.writeFileString(NodePath.join(repoDir, "README.md"), "changed before refresh\n");
857 const completed = yield* Deferred.make<void>();
858 const refresh = yield* broadcaster
859 .refreshStatus(repoDir)
860 .pipe(Effect.ensuring(Deferred.succeed(completed, undefined)), Effect.forkScoped);
861 yield* Deferred.await(gate.started);
862 const pending = Option.getOrThrow(
863 yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
864 );
865 expect(pending._tag).toBe("snapshot");
866 if (pending._tag === "snapshot") expect(pending.local.hasWorkingTreeChanges).toBe(true);
867 yield* Deferred.await(published);
868 expect(yield* Deferred.isDone(completed)).toBe(false);
869
870 yield* runGit(repoDir, ["checkout", "-b", "heads/release"]);
871 yield* runGit(repoDir, ["push", "-u", "origin", "refs/heads/heads/release"]);
872 yield* Deferred.succeed(gate.release, undefined);
873 const refreshed = yield* Fiber.join(refresh);
874 expect(refreshed.refName).toBe("heads/release");
875 expect(refreshed.hasWorkingTreeChanges).toBe(true);
876 expect(refreshed.pr).toBeNull();
877 const snapshot = Option.getOrThrow(
878 yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
879 );
880 expect(snapshot._tag).toBe("snapshot");
881 if (snapshot._tag === "snapshot") expect(snapshot.remote).toBeNull();
882
883 delete providerScenario.prListGate;
884 const recovered = yield* broadcaster.getStatus({ cwd: repoDir });
885 expect(recovered.refName).toBe("heads/release");
886 expect(recovered.pr?.number).toBe(614);
887 expect((yield* broadcaster.getStatus({ cwd: repoDir })).pr?.number).toBe(614);
888 }),
889 );
890
891 it.effect("status reports the listed PR whose head is the branch", () =>
892 Effect.gen(function* () {
893 const repoDir = yield* makeTempDir("t3code-git-manager-");
894 yield* initRepo(repoDir);
895 yield* runGit(repoDir, ["checkout", "-b", "feature/status-valid-pr-entry"]);
896 const remoteDir = yield* createBareRemote();
897 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
898 yield* runGit(repoDir, ["push", "-u", "origin", "feature/status-valid-pr-entry"]);
899
900 const { manager } = yield* makeManager({
901 providerScenario: {
902 prListSequence: [
903 [
904 {
905 number: 14,
906 title: "Another branch",
907 url: "https://github.com/pingdotgg/codething-mvp/pull/14",
908 baseRefName: "main",
909 headRefName: "feature/another-branch",
910 },
911 {
912 number: 15,
913 title: "Valid PR title",
914 url: "https://github.com/pingdotgg/codething-mvp/pull/15",
915 baseRefName: "main",
916 headRefName: "feature/status-valid-pr-entry",
917 },
918 ],
919 ],
920 },
921 });
922
923 const status = yield* manager.status({ cwd: repoDir });
924
925 expect(status.pr).toEqual({
926 number: 15,
927 title: "Valid PR title",
928 url: "https://github.com/pingdotgg/codething-mvp/pull/15",
929 baseRef: "main",
930 headRef: "feature/status-valid-pr-entry",
931 state: "open",
932 updatedAt: null,
933 });
934 }),
935 );
936
937 it.effect("status reads a remote's first URL when it has a second push URL", () =>
938 Effect.gen(function* () {
939 const repoDir = yield* makeTempDir("t3code-git-manager-");
940 yield* initRepo(repoDir);
941 yield* runGit(repoDir, ["checkout", "-b", "feature/mirrored"]);
942 const remoteDir = yield* createBareRemote();
943 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
944 yield* runGit(repoDir, ["push", "-u", "origin", "feature/mirrored"]);
945 yield* configureVisibleRemoteUrlWithLocalRewrite(
946 repoDir,
947 "origin",
948 "git@github.com:pingdotgg/codething-mvp.git",
949 remoteDir,
950 );
951 // `git remote set-url --add`: Git fetches from the first URL and also pushes to this one.
952 yield* runGit(repoDir, [
953 "config",
954 "--add",
955 "remote.origin.url",
956 "git@gitlab.com:mirror-owner/codething-mvp.git",
957 ]);
958
959 const { manager } = yield* makeManager({
960 providerScenario: {
961 prListSequence: [
962 [
963 {
964 number: 16,
965 title: "Mirrored branch",
966 url: "https://github.com/pingdotgg/codething-mvp/pull/16",
967 baseRefName: "main",
968 headRefName: "feature/mirrored",
969 isCrossRepository: false,
970 headRepositoryNameWithOwner: "pingdotgg/codething-mvp",
971 headRepositoryOwnerLogin: "pingdotgg",
972 },
973 ],
974 ],
975 },
976 });
977
978 const status = yield* manager.status({ cwd: repoDir });
979
980 expect(status.sourceControlProvider?.kind).toBe("github");
981 expect(status.pr?.number).toBe(16);
982 }),
983 );
984
985 it.effect("status reports the latest of a branch's closed and merged PRs", () =>
986 Effect.gen(function* () {
987 const repoDir = yield* makeTempDir("t3code-git-manager-");
988 yield* initRepo(repoDir);
989 yield* runGit(repoDir, ["checkout", "-b", "feature/status-lowercase-state"]);
990 const remoteDir = yield* createBareRemote();
991 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
992 yield* runGit(repoDir, ["push", "-u", "origin", "feature/status-lowercase-state"]);
993
994 const { manager } = yield* makeManager({
995 providerScenario: {
996 prListSequence: [
997 [
998 {
999 number: 16,
1000 title: "Closed PR",
1001 url: "https://github.com/pingdotgg/codething-mvp/pull/16",
1002 baseRefName: "main",
1003 headRefName: "feature/status-lowercase-state",
1004 state: "closed",
1005 updatedAt: "2026-01-01T00:00:00.000Z",
1006 },
1007 {
1008 number: 17,
1009 title: "Merged PR",
1010 url: "https://github.com/pingdotgg/codething-mvp/pull/17",
1011 baseRefName: "main",
1012 headRefName: "feature/status-lowercase-state",
1013 state: "merged",
1014 updatedAt: "2026-01-02T00:00:00.000Z",
1015 },
1016 ],
1017 ],
1018 },
1019 });
1020
1021 const status = yield* manager.status({ cwd: repoDir });
1022
1023 expect(status.pr).toEqual({
1024 number: 17,
1025 title: "Merged PR",
1026 url: "https://github.com/pingdotgg/codething-mvp/pull/17",
1027 baseRef: "main",
1028 headRef: "feature/status-lowercase-state",
1029 state: "merged",
1030 updatedAt: "2026-01-02T00:00:00.000Z",
1031 });
1032 }),
1033 );
1034
1035 it.effect("status returns an explicit non-repo result for deleted directories", () =>
1036 Effect.gen(function* () {
1037 const rootDir = yield* makeTempDir("t3code-git-manager-missing-dir-");
1038 const cwd = NodePath.join(rootDir, "deleted-repo");
1039 yield* makeDirectory(cwd);
1040 yield* removePath(cwd);
1041 const { manager } = yield* makeManager();
1042
1043 const status = yield* manager.status({ cwd });
1044
1045 expect(status).toEqual({
1046 isRepo: false,
1047 hasPrimaryRemote: false,
1048 isDefaultRef: false,
1049 refName: null,
1050 hasWorkingTreeChanges: false,
1051 workingTree: {
1052 files: [],
1053 insertions: 0,
1054 deletions: 0,
1055 },
1056 hasUpstream: false,
1057 aheadCount: 0,
1058 behindCount: 0,
1059 aheadOfDefaultCount: 0,
1060 pr: null,
1061 });
1062 }),
1063 );
1064
1065 it.effect("a git read in flight during a T3 git action does not outlive it", () =>
1066 Effect.gen(function* () {
1067 const repoDir = yield* makeTempDir("t3code-git-manager-");
1068 yield* initRepo(repoDir);
1069 const remoteDir = yield* createBareRemote();
1070 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1071 yield* runGit(repoDir, ["checkout", "-b", "feature/racing-upstream"]);
1072 yield* runGit(repoDir, ["push", "-u", "origin", "feature/racing-upstream"]);
1073 yield* runGit(repoDir, ["push", "origin", "HEAD:refs/heads/feature/raced-head"]);
1074 const pullRequest = (number: number, headRefName: string): FakeChangeRequest[] => [
1075 {
1076 number,
1077 title: headRefName,
1078 url: `https://github.com/pingdotgg/codething-mvp/pull/${number}`,
1079 baseRefName: "main",
1080 headRefName,
1081 state: "open",
1082 updatedAt: "2026-04-07T15:00:00Z",
1083 },
1084 ];
1085 const gate = {
1086 matches: (args: ReadonlyArray<string>) =>
1087 args[0] === "for-each-ref" && args.at(-1) === "refs/heads/feature/racing-upstream",
1088 reached: yield* Deferred.make<void>(),
1089 release: yield* Deferred.make<void>(),
1090 };
1091 const { manager } = yield* makeManager({
1092 gitSpawnGate: gate,
1093 providerScenario: {
1094 prListByHeadSelector: {
1095 "feature/racing-upstream": pullRequest(237, "feature/racing-upstream"),
1096 "feature/raced-head": pullRequest(238, "feature/raced-head"),
1097 },
1098 },
1099 });
1100 const lookup = manager.branchPullRequest({
1101 cwd: repoDir,
1102 branch: "feature/racing-upstream",
1103 });
1104
1105 const inFlight = yield* Effect.forkChild(lookup);
1106 yield* Deferred.await(gate.reached);
1107 yield* runGit(repoDir, ["branch", "--set-upstream-to=origin/feature/raced-head"]);
1108 yield* manager.invalidateStatus(repoDir);
1109 yield* Deferred.succeed(gate.release, undefined);
1110 yield* Fiber.join(inFlight);
1111
1112 expect((yield* lookup)?.number).toBe(238);
1113 }),
1114 );
1115
1116 it.effect("branch PR lookup notifies linked threads when draft status changes", () =>
1117 Effect.gen(function* () {
1118 const repoDir = yield* makeTempDir("t3code-git-manager-");
1119 yield* initRepo(repoDir);
1120 yield* runGit(repoDir, ["checkout", "-b", "feature/draft-status"]);
1121 const remoteDir = yield* createBareRemote();
1122 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1123 yield* runGit(repoDir, ["push", "-u", "origin", "feature/draft-status"]);
1124 const drafts = [false, true, true, false, false, true];
1125 const pullRequest: FakeChangeRequest = {
1126 number: 1,
1127 title: "Draft status",
1128 url: "https://github.com/pingdotgg/codething-mvp/pull/1",
1129 baseRefName: "main",
1130 headRefName: "feature/draft-status",
1131 state: "open",
1132 };
1133 const { manager } = yield* makeManager({
1134 providerScenario: {
1135 prListSequence: [
1136 ...drafts.map((isDraft) => [{ ...pullRequest, isDraft }]),
1137 [
1138 {
1139 ...pullRequest,
1140 number: 2,
1141 url: "https://github.com/pingdotgg/codething-mvp/pull/2",
1142 state: "merged",
1143 },
1144 ],
1145 ],
1146 },
1147 });
1148 const changes = yield* manager.subscribePullRequestStateChanges;
1149 for (const isDraft of drafts) {
1150 const pr = yield* manager.branchPullRequest(
1151 { cwd: repoDir, branch: "feature/draft-status" },
1152 { refresh: true },
1153 );
1154 expect(pr?.isDraft === true).toBe(isDraft);
1155 }
1156 // A different PR ends collection without waiting on a background stream consumer.
1157 yield* manager.branchPullRequest(
1158 { cwd: repoDir, branch: "feature/draft-status" },
1159 { refresh: true },
1160 );
1161 const events = yield* Stream.runCollect(
1162 changes.pipe(Stream.takeUntil((event) => event.number === 2, { excludeLast: true })),
1163 );
1164 expect(events).toEqual([
1165 { host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
1166 { host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
1167 { host: "github.com", repository: "pingdotgg/codething-mvp", number: 1 },
1168 ]);
1169 }),
1170 );
1171
1172 it.effect("a settled branch PR is rechecked only when the branch moves or every 15 minutes", () =>
1173 Effect.gen(function* () {
1174 const repoDir = yield* makeTempDir("t3code-git-manager-");
1175 yield* initRepo(repoDir);
1176 const remoteDir = yield* createBareRemote();
1177 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1178 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1179 yield* runGit(repoDir, ["checkout", "-b", "feature/settled"]);
1180 yield* runGit(repoDir, ["push", "-u", "origin", "feature/settled"]);
1181 const pullRequest = (number: number, state: "open" | "merged"): FakeChangeRequest => ({
1182 number,
1183 title: "Settled",
1184 url: `https://github.com/pingdotgg/codething-mvp/pull/${number}`,
1185 baseRefName: "main",
1186 headRefName: "feature/settled",
1187 state,
1188 updatedAt: `2026-04-0${number}T15:00:00Z`,
1189 });
1190 const gitCommands: string[] = [];
1191 const { manager } = yield* makeManager({
1192 gitCommands,
1193 providerScenario: {
1194 prListSequence: [
1195 [pullRequest(1, "merged")],
1196 [pullRequest(1, "merged")],
1197 [pullRequest(1, "merged")],
1198 ],
1199 prListOtherwise: [pullRequest(2, "open")],
1200 },
1201 });
1202 const lookup = manager.branchPullRequest({ cwd: repoDir, branch: "feature/settled" });
1203 const freshLookups = () => gitCommands.filter((args) => args === "remote").length;
1204
1205 expect((yield* lookup)?.state).toBe("merged");
1206 gitCommands.length = 0;
1207 expect((yield* lookup)?.state).toBe("merged");
1208 expect((yield* lookup)?.state).toBe("merged");
1209 expect(gitCommands.map((args) => args.split(" ", 1)[0]).toSorted()).toEqual([
1210 "config",
1211 "config",
1212 "for-each-ref",
1213 "for-each-ref",
1214 ]);
1215 expect(freshLookups()).toBe(0);
1216 gitCommands.length = 0;
1217 yield* manager.branchPullRequest(
1218 { cwd: repoDir, branch: "feature/settled" },
1219 { confirmTerminal: false },
1220 );
1221 expect(gitCommands).toEqual([]);
1222
1223 NodeFS.writeFileSync(NodePath.join(repoDir, "settled.txt"), "new work\n");
1224 yield* runGit(repoDir, ["add", "settled.txt"]);
1225 yield* runGit(repoDir, ["commit", "-m", "New work"]);
1226 gitCommands.length = 0;
1227 expect((yield* lookup)?.state).toBe("merged");
1228 expect(freshLookups()).toBe(1);
1229 gitCommands.length = 0;
1230 yield* lookup;
1231 expect(freshLookups()).toBe(0);
1232
1233 // Remembered git state expires after 5 minutes; that rereads git without a recheck.
1234 yield* TestClock.adjust("10 minutes");
1235 gitCommands.length = 0;
1236 expect((yield* lookup)?.state).toBe("merged");
1237 expect(freshLookups()).toBe(1);
1238
1239 yield* TestClock.adjust("5 minutes");
1240 gitCommands.length = 0;
1241 expect((yield* lookup)?.state).toBe("merged");
1242 expect(freshLookups()).toBe(2);
1243
1244 // A new PR from the reused branch shows on the next host query.
1245 yield* TestClock.adjust("5 minutes");
1246 expect((yield* lookup)?.number).toBe(2);
1247 }),
1248 );
1249
1250 it.effect("branch PR lookup uses a saved tracked branch without changing checkout", () =>
1251 Effect.gen(function* () {
1252 const repoDir = yield* makeTempDir("t3code-git-manager-");
1253 yield* initRepo(repoDir);
1254 const remoteDir = yield* createBareRemote();
1255 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1256 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1257 yield* runGit(repoDir, ["checkout", "-b", "feature/saved-branch"]);
1258 yield* runGit(repoDir, ["push", "-u", "origin", "feature/saved-branch"]);
1259 yield* runGit(repoDir, ["checkout", "main"]);
1260
1261 const { manager } = yield* makeManager({
1262 providerScenario: {
1263 prListSequence: [
1264 [
1265 {
1266 number: 216,
1267 title: "Saved branch PR",
1268 url: "https://github.com/pingdotgg/t3code/pull/216",
1269 baseRefName: "main",
1270 headRefName: "feature/saved-branch",
1271 headSha: "a".repeat(40),
1272 state: "open",
1273 updatedAt: "2026-04-03T15:00:00Z",
1274 },
1275 ],
1276 ],
1277 },
1278 });
1279
1280 const pullRequest = yield* manager.branchPullRequest({
1281 cwd: repoDir,
1282 branch: "feature/saved-branch",
1283 });
1284
1285 expect(pullRequest).toMatchObject({
1286 number: 216,
1287 title: "Saved branch PR",
1288 url: "https://github.com/pingdotgg/t3code/pull/216",
1289 baseRef: "main",
1290 headRef: "feature/saved-branch",
1291 headSha: "a".repeat(40),
1292 state: "open",
1293 closedAt: null,
1294 mergedAt: null,
1295 updatedAt: "2026-04-03T15:00:00.000Z",
1296 });
1297 expect((yield* runGit(repoDir, ["branch", "--show-current"])).stdout.trim()).toBe("main");
1298 }),
1299 );
1300
1301 it.effect("branch PR lookup uses the default branch from a non-origin remote", () =>
1302 Effect.gen(function* () {
1303 const repoDir = yield* makeTempDir("t3code-git-manager-");
1304 yield* initRepo(repoDir);
1305 const remoteDir = yield* createBareRemote();
1306 yield* runGit(repoDir, ["remote", "add", "upstream", remoteDir]);
1307 yield* runGit(repoDir, ["push", "-u", "upstream", "main"]);
1308 yield* runGit(repoDir, ["checkout", "-b", "develop"]);
1309 yield* runGit(repoDir, ["push", "-u", "upstream", "develop"]);
1310 yield* runGit(remoteDir, ["--git-dir=.", "symbolic-ref", "HEAD", "refs/heads/develop"]);
1311 yield* runGit(repoDir, ["remote", "set-head", "upstream", "develop"]);
1312
1313 const { manager } = yield* makeManager({
1314 providerScenario: {
1315 prListSequence: [
1316 [
1317 {
1318 number: 221,
1319 title: "Merged main PR",
1320 url: "https://github.com/pingdotgg/codething-mvp/pull/221",
1321 baseRefName: "develop",
1322 headRefName: "main",
1323 state: "merged",
1324 mergedAt: "2026-04-07T15:00:00Z",
1325 updatedAt: "2026-04-08T15:00:00Z",
1326 },
1327 ],
1328 ],
1329 },
1330 });
1331
1332 const pullRequest = yield* manager.branchPullRequest({ cwd: repoDir, branch: "main" });
1333
1334 expect(pullRequest).toMatchObject({
1335 state: "merged",
1336 closedAt: null,
1337 mergedAt: "2026-04-07T15:00:00Z",
1338 updatedAt: "2026-04-08T15:00:00.000Z",
1339 });
1340 }),
1341 );
1342
1343 it.effect("branch PR lookup uses the saved name after the local branch is deleted", () =>
1344 Effect.gen(function* () {
1345 const repoDir = yield* makeTempDir("t3code-git-manager-");
1346 yield* initRepo(repoDir);
1347 const remoteDir = yield* createBareRemote();
1348 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1349 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1350 yield* runGit(repoDir, ["checkout", "-b", "feature/deleted-local-branch"]);
1351 yield* runGit(repoDir, ["push", "-u", "origin", "feature/deleted-local-branch"]);
1352 yield* runGit(repoDir, ["checkout", "main"]);
1353 yield* runGit(repoDir, ["branch", "-D", "feature/deleted-local-branch"]);
1354 yield* runGit(repoDir, ["branch", "feature/deleted-local-branch/child"]);
1355 yield* runGit(repoDir, [
1356 "branch",
1357 "--set-upstream-to",
1358 "origin/main",
1359 "feature/deleted-local-branch/child",
1360 ]);
1361
1362 const { manager, providerCalls } = yield* makeManager({
1363 providerScenario: {
1364 prListSequence: [
1365 [
1366 {
1367 number: 217,
1368 title: "Deleted local branch PR",
1369 url: "https://github.com/pingdotgg/t3code/pull/217",
1370 baseRefName: "main",
1371 headRefName: "feature/deleted-local-branch",
1372 state: "merged",
1373 updatedAt: "2026-04-04T15:00:00Z",
1374 },
1375 ],
1376 ],
1377 },
1378 });
1379
1380 const pullRequest = yield* manager.branchPullRequest({
1381 cwd: repoDir,
1382 branch: "feature/deleted-local-branch",
1383 });
1384
1385 expect(pullRequest).toMatchObject({
1386 state: "merged",
1387 closedAt: null,
1388 mergedAt: null,
1389 updatedAt: "2026-04-04T15:00:00.000Z",
1390 });
1391 expect(listedSelectors(providerCalls).includes("feature/deleted-local-branch")).toBe(true);
1392 }),
1393 );
1394
1395 it.effect("branch PR lookup recovers a deleted fork branch from its remote-tracking ref", () =>
1396 Effect.gen(function* () {
1397 const repoDir = yield* makeTempDir("t3code-git-manager-");
1398 yield* initRepo(repoDir);
1399 const originDir = yield* createBareRemote();
1400 const forkDir = yield* createBareRemote();
1401 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
1402 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1403 yield* configureRemote(repoDir, "team/fork", forkDir, "team/fork");
1404 yield* runGit(repoDir, ["checkout", "-b", "feature/deleted-fork-branch"]);
1405 yield* runGit(repoDir, ["push", "-u", "team/fork", "feature/deleted-fork-branch"]);
1406 yield* runGit(repoDir, ["checkout", "main"]);
1407 yield* runGit(repoDir, ["branch", "-D", "feature/deleted-fork-branch"]);
1408 yield* configureVisibleRemoteUrlWithLocalRewrite(
1409 repoDir,
1410 "origin",
1411 "git@github.com:pingdotgg/codething-mvp.git",
1412 originDir,
1413 );
1414 yield* configureVisibleRemoteUrlWithLocalRewrite(
1415 repoDir,
1416 "team/fork",
1417 "git@github.com:contributor/codething-mvp.git",
1418 forkDir,
1419 );
1420
1421 const { manager, providerCalls } = yield* makeManager({
1422 providerScenario: {
1423 prListByHeadSelector: {
1424 "feature/deleted-fork-branch": [
1425 {
1426 number: 218,
1427 title: "Deleted fork branch PR",
1428 url: "https://github.com/pingdotgg/codething-mvp/pull/218",
1429 baseRefName: "main",
1430 headRefName: "feature/deleted-fork-branch",
1431 state: "merged",
1432 updatedAt: "2026-04-05T15:00:00Z",
1433 isCrossRepository: true,
1434 headRepositoryNameWithOwner: "contributor/codething-mvp",
1435 headRepositoryOwnerLogin: "contributor",
1436 },
1437 ],
1438 },
1439 },
1440 });
1441
1442 const pullRequest = yield* manager.branchPullRequest({
1443 cwd: repoDir,
1444 branch: "feature/deleted-fork-branch",
1445 });
1446
1447 expect(pullRequest).toMatchObject({
1448 state: "merged",
1449 closedAt: null,
1450 mergedAt: null,
1451 updatedAt: "2026-04-05T15:00:00.000Z",
1452 });
1453 expect(
1454 listed(providerCalls).some(
1455 (call) => call.headSelector === "feature/deleted-fork-branch" && call.state === "all",
1456 ),
1457 ).toBe(true);
1458 expect(
1459 listedSelectors(providerCalls).some((selector) => selector.startsWith("contributor:")),
1460 ).toBe(false);
1461 }),
1462 );
1463
1464 it.effect("branch PR lookup rejects ambiguous deleted-branch remote refs", () =>
1465 Effect.gen(function* () {
1466 const repoDir = yield* makeTempDir("t3code-git-manager-");
1467 yield* initRepo(repoDir);
1468 const originDir = yield* createBareRemote();
1469 const forkDir = yield* createBareRemote();
1470 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
1471 yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
1472 yield* runGit(repoDir, ["checkout", "-b", "feature/ambiguous-remote"]);
1473 yield* runGit(repoDir, ["push", "origin", "feature/ambiguous-remote"]);
1474 yield* runGit(repoDir, ["push", "fork", "feature/ambiguous-remote"]);
1475 yield* runGit(repoDir, ["checkout", "main"]);
1476 yield* runGit(repoDir, ["branch", "-D", "feature/ambiguous-remote"]);
1477 const { manager, providerCalls } = yield* makeManager();
1478
1479 const error = yield* manager
1480 .branchPullRequest({ cwd: repoDir, branch: "feature/ambiguous-remote" })
1481 .pipe(Effect.flip);
1482
1483 expect(error).toMatchObject({
1484 _tag: "GitManagerError",
1485 detail: "Multiple remotes track feature/ambiguous-remote. Its pull request is ambiguous.",
1486 });
1487 expect(providerCalls).toHaveLength(0);
1488 }),
1489 );
1490
1491 it.effect("finds a fork PR for a branch pushed without an upstream", () =>
1492 Effect.gen(function* () {
1493 const repoDir = yield* makeTempDir("t3code-git-manager-");
1494 yield* initRepo(repoDir);
1495 const originDir = yield* createBareRemote();
1496 const forkDir = yield* createBareRemote();
1497 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
1498 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1499 yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
1500 yield* runGit(repoDir, ["checkout", "-b", "feature/no-upstream-fork"]);
1501 yield* runGit(repoDir, ["push", "fork", "feature/no-upstream-fork"]);
1502 yield* configureVisibleRemoteUrlWithLocalRewrite(
1503 repoDir,
1504 "origin",
1505 "git@github.com:pingdotgg/codething-mvp.git",
1506 originDir,
1507 );
1508 yield* configureVisibleRemoteUrlWithLocalRewrite(
1509 repoDir,
1510 "fork",
1511 "git@github.com:contributor/codething-mvp.git",
1512 forkDir,
1513 );
1514
1515 const providerScenario: FakeProviderScenario = {
1516 prListByHeadSelector: {
1517 "feature/no-upstream-fork": [
1518 {
1519 number: 40,
1520 title: "Another fork's PR",
1521 url: "https://github.com/pingdotgg/codething-mvp/pull/40",
1522 baseRefName: "main",
1523 headRefName: "feature/no-upstream-fork",
1524 state: "open",
1525 isCrossRepository: true,
1526 headRepositoryNameWithOwner: "someone-else/codething-mvp",
1527 headRepositoryOwnerLogin: "someone-else",
1528 },
1529 {
1530 number: 41,
1531 title: "Our fork's PR",
1532 url: "https://github.com/pingdotgg/codething-mvp/pull/41",
1533 baseRefName: "main",
1534 headRefName: "feature/no-upstream-fork",
1535 state: "open",
1536 isCrossRepository: true,
1537 headRepositoryNameWithOwner: "contributor/codething-mvp",
1538 headRepositoryOwnerLogin: "contributor",
1539 },
1540 ],
1541 },
1542 };
1543 const { manager } = yield* makeManager({ providerScenario });
1544
1545 const pullRequest = yield* manager.branchPullRequest({
1546 cwd: repoDir,
1547 branch: "feature/no-upstream-fork",
1548 });
1549 expect(pullRequest?.number).toBe(41);
1550 expect((yield* manager.status({ cwd: repoDir })).pr?.number).toBe(41);
1551
1552 yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Continue feature"]);
1553 const localHead = yield* runGit(repoDir, ["rev-parse", "HEAD"]);
1554 const pushedHead = yield* runGit(repoDir, [
1555 "rev-parse",
1556 "refs/remotes/fork/feature/no-upstream-fork",
1557 ]);
1558 expect(localHead.stdout.trim()).not.toBe(pushedHead.stdout.trim());
1559 const { manager: aheadManager } = yield* makeManager({ providerScenario });
1560 expect(
1561 (yield* aheadManager.branchPullRequest({
1562 cwd: repoDir,
1563 branch: "feature/no-upstream-fork",
1564 }))?.number,
1565 ).toBe(41);
1566 expect((yield* aheadManager.status({ cwd: repoDir })).pr?.number).toBe(41);
1567
1568 yield* runGit(repoDir, ["config", "branch.feature/no-upstream-fork.remote", "origin"]);
1569 const upstream = yield* runGit(repoDir, [
1570 "for-each-ref",
1571 "--format=%(upstream:short)",
1572 "refs/heads/feature/no-upstream-fork",
1573 ]);
1574 expect(upstream.stdout.trim()).toBe("");
1575 const { manager: staleRemoteManager } = yield* makeManager({ providerScenario });
1576 expect(
1577 (yield* staleRemoteManager.branchPullRequest({
1578 cwd: repoDir,
1579 branch: "feature/no-upstream-fork",
1580 }))?.number,
1581 ).toBe(41);
1582
1583 yield* runGit(repoDir, ["config", "--unset", "branch.feature/no-upstream-fork.remote"]);
1584 yield* runGit(repoDir, ["checkout", "-b", "diverged-push", "main"]);
1585 yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Rewrite fork head"]);
1586 yield* runGit(repoDir, [
1587 "push",
1588 "--force",
1589 "fork",
1590 "HEAD:refs/heads/feature/no-upstream-fork",
1591 ]);
1592 yield* runGit(repoDir, ["checkout", "feature/no-upstream-fork"]);
1593 const { manager: divergedManager } = yield* makeManager({ providerScenario });
1594 expect(
1595 yield* divergedManager.branchPullRequest({
1596 cwd: repoDir,
1597 branch: "feature/no-upstream-fork",
1598 }),
1599 ).toBeNull();
1600 }),
1601 );
1602
1603 it.effect("prefers an exact fork ref but does not guess between equal refs", () =>
1604 Effect.gen(function* () {
1605 const repoDir = yield* makeTempDir("t3code-git-manager-");
1606 yield* initRepo(repoDir);
1607 const originDir = yield* createBareRemote();
1608 const firstForkDir = yield* createBareRemote();
1609 const secondForkDir = yield* createBareRemote();
1610 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
1611 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1612 yield* runGit(repoDir, ["remote", "add", "first-fork", firstForkDir]);
1613 yield* runGit(repoDir, ["remote", "add", "second-fork", secondForkDir]);
1614 yield* runGit(repoDir, ["checkout", "-b", "feature/ambiguous-fork"]);
1615 yield* runGit(repoDir, ["push", "first-fork", "feature/ambiguous-fork"]);
1616 yield* configureVisibleRemoteUrlWithLocalRewrite(
1617 repoDir,
1618 "origin",
1619 "git@github.com:pingdotgg/codething-mvp.git",
1620 originDir,
1621 );
1622 yield* configureVisibleRemoteUrlWithLocalRewrite(
1623 repoDir,
1624 "first-fork",
1625 "git@github.com:contributor/codething-mvp.git",
1626 firstForkDir,
1627 );
1628 yield* configureVisibleRemoteUrlWithLocalRewrite(
1629 repoDir,
1630 "second-fork",
1631 "git@github.com:someone-else/codething-mvp.git",
1632 secondForkDir,
1633 );
1634
1635 const providerScenario: FakeProviderScenario = {
1636 prListByHeadSelector: {
1637 "feature/ambiguous-fork": [
1638 {
1639 number: 41,
1640 title: "One fork's PR",
1641 url: "https://github.com/pingdotgg/codething-mvp/pull/41",
1642 baseRefName: "main",
1643 headRefName: "feature/ambiguous-fork",
1644 state: "open",
1645 isCrossRepository: true,
1646 headRepositoryNameWithOwner: "contributor/codething-mvp",
1647 headRepositoryOwnerLogin: "contributor",
1648 },
1649 ],
1650 },
1651 };
1652 const { manager: singleRemoteManager } = yield* makeManager({ providerScenario });
1653 expect(
1654 (yield* singleRemoteManager.branchPullRequest({
1655 cwd: repoDir,
1656 branch: "feature/ambiguous-fork",
1657 }))?.number,
1658 ).toBe(41);
1659
1660 yield* runGit(repoDir, ["push", "second-fork", "feature/ambiguous-fork"]);
1661 const { manager } = yield* makeManager({ providerScenario });
1662 expect(
1663 yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/ambiguous-fork" }),
1664 ).toBeNull();
1665
1666 yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Continue feature"]);
1667 yield* runGit(repoDir, ["push", "first-fork", "feature/ambiguous-fork"]);
1668 const { manager: exactManager } = yield* makeManager({ providerScenario });
1669 expect(
1670 (yield* exactManager.branchPullRequest({
1671 cwd: repoDir,
1672 branch: "feature/ambiguous-fork",
1673 }))?.number,
1674 ).toBe(41);
1675 }),
1676 );
1677
1678 it.effect("does not guess a fork when an ancestry probe fails", () =>
1679 Effect.gen(function* () {
1680 const repoDir = yield* makeTempDir("t3code-git-manager-");
1681 yield* initRepo(repoDir);
1682 const originDir = yield* createBareRemote();
1683 const forkDir = yield* createBareRemote();
1684 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
1685 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1686 yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
1687 yield* runGit(repoDir, ["checkout", "-b", "feature/failed-probe"]);
1688 yield* runGit(repoDir, ["push", "fork", "feature/failed-probe"]);
1689 yield* runGit(repoDir, ["push", "origin", "feature/failed-probe"]);
1690 yield* runGit(repoDir, ["commit", "--allow-empty", "-m", "Local work"]);
1691 const treeOid = (yield* runGit(repoDir, ["rev-parse", "HEAD^{tree}"])).stdout.trim();
1692 yield* runGit(repoDir, ["update-ref", "refs/remotes/origin/feature/failed-probe", treeOid]);
1693 const forkProbe = yield* runGit(
1694 repoDir,
1695 ["merge-base", "--is-ancestor", "refs/remotes/fork/feature/failed-probe", "HEAD"],
1696 true,
1697 );
1698 expect(forkProbe.exitCode).toBe(0);
1699 const originProbe = yield* runGit(
1700 repoDir,
1701 ["merge-base", "--is-ancestor", "refs/remotes/origin/feature/failed-probe", "HEAD"],
1702 true,
1703 );
1704 expect(originProbe.exitCode).not.toBe(0);
1705 expect(originProbe.exitCode).not.toBe(1);
1706 yield* configureVisibleRemoteUrlWithLocalRewrite(
1707 repoDir,
1708 "origin",
1709 "git@github.com:pingdotgg/codething-mvp.git",
1710 originDir,
1711 );
1712 yield* configureVisibleRemoteUrlWithLocalRewrite(
1713 repoDir,
1714 "fork",
1715 "git@github.com:contributor/codething-mvp.git",
1716 forkDir,
1717 );
1718
1719 const providerScenario: FakeProviderScenario = {
1720 prListByHeadSelector: {
1721 "feature/failed-probe": [
1722 {
1723 number: 43,
1724 title: "Failed probe PR",
1725 url: "https://github.com/pingdotgg/codething-mvp/pull/43",
1726 baseRefName: "main",
1727 headRefName: "feature/failed-probe",
1728 state: "open",
1729 isCrossRepository: true,
1730 headRepositoryNameWithOwner: "contributor/codething-mvp",
1731 headRepositoryOwnerLogin: "contributor",
1732 },
1733 ],
1734 },
1735 };
1736 const { manager } = yield* makeManager({ providerScenario });
1737 expect(
1738 yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/failed-probe" }),
1739 ).toBeNull();
1740 }),
1741 );
1742
1743 it.effect("finds a fork PR when the remote name contains a slash", () =>
1744 Effect.gen(function* () {
1745 const repoDir = yield* makeTempDir("t3code-git-manager-");
1746 yield* initRepo(repoDir);
1747 const originDir = yield* createBareRemote();
1748 const forkDir = yield* createBareRemote();
1749 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
1750 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1751 yield* runGit(repoDir, ["remote", "add", "team/fork", forkDir]);
1752 yield* runGit(repoDir, ["checkout", "-b", "feature/slash-remote"]);
1753 yield* runGit(repoDir, ["push", "team/fork", "feature/slash-remote"]);
1754 yield* configureVisibleRemoteUrlWithLocalRewrite(
1755 repoDir,
1756 "origin",
1757 "git@github.com:pingdotgg/codething-mvp.git",
1758 originDir,
1759 );
1760 yield* configureVisibleRemoteUrlWithLocalRewrite(
1761 repoDir,
1762 "team/fork",
1763 "git@github.com:contributor/codething-mvp.git",
1764 forkDir,
1765 );
1766
1767 const { manager } = yield* makeManager({
1768 providerScenario: {
1769 prListByHeadSelector: {
1770 "feature/slash-remote": [
1771 {
1772 number: 42,
1773 title: "Slash remote PR",
1774 url: "https://github.com/pingdotgg/codething-mvp/pull/42",
1775 baseRefName: "main",
1776 headRefName: "feature/slash-remote",
1777 state: "open",
1778 isCrossRepository: true,
1779 headRepositoryNameWithOwner: "contributor/codething-mvp",
1780 headRepositoryOwnerLogin: "contributor",
1781 },
1782 ],
1783 },
1784 },
1785 });
1786
1787 expect(
1788 (yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature/slash-remote" }))
1789 ?.number,
1790 ).toBe(42);
1791 }),
1792 );
1793
1794 it.effect("branch PR lookup does not reuse a cached PR after the remote is repointed", () =>
1795 Effect.gen(function* () {
1796 const repoDir = yield* makeTempDir("t3code-git-manager-");
1797 yield* initRepo(repoDir);
1798 const originalRemoteDir = yield* createBareRemote();
1799 yield* runGit(repoDir, ["remote", "add", "origin", originalRemoteDir]);
1800 yield* runGit(repoDir, ["checkout", "-b", "feature/repointed-lookup"]);
1801 yield* runGit(repoDir, ["push", "-u", "origin", "feature/repointed-lookup"]);
1802 yield* configureVisibleRemoteUrlWithLocalRewrite(
1803 repoDir,
1804 "origin",
1805 "git@github.com:old-owner/old-repository.git",
1806 originalRemoteDir,
1807 );
1808 const { manager, providerCalls } = yield* makeManager({
1809 providerScenario: {
1810 prListSequence: [
1811 [
1812 {
1813 number: 219,
1814 title: "Old repository PR",
1815 url: "https://github.com/old-owner/old-repository/pull/219",
1816 baseRefName: "main",
1817 headRefName: "feature/repointed-lookup",
1818 state: "merged",
1819 updatedAt: "2026-04-06T15:00:00Z",
1820 },
1821 ],
1822 [],
1823 ],
1824 },
1825 });
1826
1827 const first = yield* manager.branchPullRequest({
1828 cwd: repoDir,
1829 branch: "feature/repointed-lookup",
1830 });
1831 expect(first?.state).toBe("merged");
1832
1833 const replacementRemoteDir = yield* createBareRemote();
1834 yield* configureVisibleRemoteUrlWithLocalRewrite(
1835 repoDir,
1836 "origin",
1837 "git@github.com:new-owner/new-repository.git",
1838 replacementRemoteDir,
1839 );
1840
1841 const second = yield* manager.branchPullRequest({
1842 cwd: repoDir,
1843 branch: "feature/repointed-lookup",
1844 });
1845
1846 expect(second).toBeNull();
1847 expect(listed(providerCalls)).toHaveLength(2);
1848 }),
1849 );
1850
1851 // regression: #8600 settle threads server-side
1852 it.effect("branch PR lookup propagates provider failures", () =>
1853 Effect.gen(function* () {
1854 const repoDir = yield* makeTempDir("t3code-git-manager-");
1855 yield* initRepo(repoDir);
1856 const remoteDir = yield* createBareRemote();
1857 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1858 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1859 yield* runGit(repoDir, ["checkout", "-b", "feature/lookup-failure"]);
1860 yield* runGit(repoDir, ["push", "-u", "origin", "feature/lookup-failure"]);
1861 yield* runGit(repoDir, ["checkout", "main"]);
1862
1863 const { manager, providerCalls } = yield* makeManager({
1864 providerScenario: {
1865 failWith: "The host is signed out.",
1866 },
1867 });
1868
1869 const error = yield* manager
1870 .branchPullRequest({ cwd: repoDir, branch: "feature/lookup-failure" })
1871 .pipe(Effect.flip);
1872
1873 expect(error._tag).toBe("SourceControlProviderError");
1874 const refreshError = yield* manager
1875 .branchPullRequest({ cwd: repoDir, branch: "feature/lookup-failure" }, { refresh: true })
1876 .pipe(Effect.flip);
1877 expect(refreshError._tag).toBe("SourceControlProviderError");
1878 expect(listed(providerCalls)).toHaveLength(1);
1879 }),
1880 );
1881
1882 it.effect("status finds a merged PR after its remote branch was deleted", () =>
1883 Effect.gen(function* () {
1884 const repoDir = yield* makeTempDir("t3code-git-manager-");
1885 yield* initRepo(repoDir);
1886 const remoteDir = yield* createBareRemote();
1887 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1888 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1889 yield* runGit(repoDir, ["checkout", "-b", "feature/merged-branch-deleted"]);
1890 yield* runGit(repoDir, ["push", "-u", "origin", "feature/merged-branch-deleted"]);
1891
1892 // Deleting a merged head removes its tracking ref but leaves remote/merge config proving publication.
1893 yield* runGit(repoDir, ["push", "origin", "--delete", "feature/merged-branch-deleted"]);
1894 const configuredRemote = yield* runGit(repoDir, [
1895 "config",
1896 "--get",
1897 "branch.feature/merged-branch-deleted.remote",
1898 ]);
1899 const configuredMerge = yield* runGit(repoDir, [
1900 "config",
1901 "--get",
1902 "branch.feature/merged-branch-deleted.merge",
1903 ]);
1904 const trackingRef = yield* runGit(repoDir, [
1905 "for-each-ref",
1906 "--format=%(refname)",
1907 "refs/remotes/origin/feature/merged-branch-deleted",
1908 ]);
1909 expect(configuredRemote.stdout.trim()).toBe("origin");
1910 expect(configuredMerge.stdout.trim()).toBe("refs/heads/feature/merged-branch-deleted");
1911 expect(trackingRef.stdout.trim()).toBe("");
1912
1913 const { manager, providerCalls } = yield* makeManager({
1914 providerScenario: {
1915 prListSequence: [
1916 [
1917 {
1918 number: 215,
1919 title: "Merged branch was deleted",
1920 url: "https://github.com/pingdotgg/t3code/pull/215",
1921 baseRefName: "main",
1922 headRefName: "feature/merged-branch-deleted",
1923 state: "merged",
1924 mergedAt: "2026-04-02T15:00:00Z",
1925 updatedAt: "2026-04-02T15:00:00Z",
1926 },
1927 ],
1928 ],
1929 },
1930 });
1931
1932 const status = yield* manager.status({ cwd: repoDir });
1933
1934 expect(status.hasUpstream).toBe(false);
1935 expect(status.pr).toEqual({
1936 number: 215,
1937 title: "Merged branch was deleted",
1938 url: "https://github.com/pingdotgg/t3code/pull/215",
1939 baseRef: "main",
1940 headRef: "feature/merged-branch-deleted",
1941 state: "merged",
1942 updatedAt: "2026-04-02T15:00:00.000Z",
1943 });
1944 expect(listed(providerCalls).length).toBeGreaterThan(0);
1945 }),
1946 );
1947
1948 function squashMergeIntoRemoteMain(repoDir: string, branch: string) {
1949 return Effect.gen(function* () {
1950 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
1951 yield* runGit(repoDir, ["checkout", "-b", branch]);
1952 NodeFS.writeFileSync(NodePath.join(repoDir, "squash.txt"), "one\ntwo\n");
1953 yield* runGit(repoDir, ["add", "squash.txt"]);
1954 yield* runGit(repoDir, ["commit", "-m", "Feature work"]);
1955 yield* runGit(repoDir, ["push", "-u", "origin", branch]);
1956 // The host squash-merges: a new commit on main with the branch's tree, not the branch's commit.
1957 const squash = yield* runGit(repoDir, [
1958 "commit-tree",
1959 "HEAD^{tree}",
1960 "-p",
1961 "origin/main",
1962 "-m",
1963 "Feature work (#217)",
1964 ]);
1965 yield* runGit(repoDir, ["push", "origin", `${squash.stdout.trim()}:refs/heads/main`]);
1966 return (yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout.trim();
1967 });
1968 }
1969
1970 const squashMergedPr = (branch: string, headSha: string): FakeChangeRequest => ({
1971 number: 217,
1972 title: "Feature work",
1973 url: "https://github.com/pingdotgg/t3code/pull/217",
1974 baseRefName: "main",
1975 headRefName: branch,
1976 headSha,
1977 state: "merged",
1978 mergedAt: "2026-04-02T15:00:00Z",
1979 updatedAt: "2026-04-02T15:00:00Z",
1980 });
1981
1982 it.effect("status reports nothing to ship after a squash merge deleted the remote branch", () =>
1983 Effect.gen(function* () {
1984 const repoDir = yield* makeTempDir("t3code-git-manager-");
1985 yield* initRepo(repoDir);
1986 const remoteDir = yield* createBareRemote();
1987 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
1988 const branch = "feature/squash-deleted";
1989 const headSha = yield* squashMergeIntoRemoteMain(repoDir, branch);
1990 yield* runGit(repoDir, ["push", "origin", "--delete", branch]);
1991 yield* runGit(repoDir, ["fetch", "--prune", "origin"]);
1992
1993 const { manager } = yield* makeManager({
1994 providerScenario: { prListSequence: [[squashMergedPr(branch, headSha)]] },
1995 });
1996
1997 const status = yield* manager.status({ cwd: repoDir });
1998
1999 expect(status.pr?.state).toBe("merged");
2000 expect(status.hasUpstream).toBe(false);
2001 expect({
2002 aheadCount: status.aheadCount,
2003 aheadOfDefaultCount: status.aheadOfDefaultCount,
2004 }).toEqual({ aheadCount: 0, aheadOfDefaultCount: 0 });
2005 }),
2006 );
2007
2008 it.effect("status reports nothing to ship after a squash merge kept the remote branch", () =>
2009 Effect.gen(function* () {
2010 const repoDir = yield* makeTempDir("t3code-git-manager-");
2011 yield* initRepo(repoDir);
2012 const remoteDir = yield* createBareRemote();
2013 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2014 const branch = "feature/squash-kept";
2015 const headSha = yield* squashMergeIntoRemoteMain(repoDir, branch);
2016 yield* runGit(repoDir, ["fetch", "--prune", "origin"]);
2017
2018 const { manager } = yield* makeManager({
2019 providerScenario: { prListSequence: [[squashMergedPr(branch, headSha)]] },
2020 });
2021
2022 const status = yield* manager.status({ cwd: repoDir });
2023
2024 expect(status.pr?.state).toBe("merged");
2025 expect(status.hasUpstream).toBe(true);
2026 expect({
2027 aheadCount: status.aheadCount,
2028 aheadOfDefaultCount: status.aheadOfDefaultCount,
2029 }).toEqual({ aheadCount: 0, aheadOfDefaultCount: 0 });
2030 }),
2031 );
2032
2033 it.effect("status still reports work to ship for a commit added after a squash merge", () =>
2034 Effect.gen(function* () {
2035 const repoDir = yield* makeTempDir("t3code-git-manager-");
2036 yield* initRepo(repoDir);
2037 const remoteDir = yield* createBareRemote();
2038 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2039 const branch = "feature/squash-follow-up";
2040 const headSha = yield* squashMergeIntoRemoteMain(repoDir, branch);
2041 NodeFS.writeFileSync(NodePath.join(repoDir, "follow-up.txt"), "after merge\n");
2042 yield* runGit(repoDir, ["add", "follow-up.txt"]);
2043 yield* runGit(repoDir, ["commit", "-m", "Follow-up work"]);
2044 yield* runGit(repoDir, ["fetch", "--prune", "origin"]);
2045
2046 const { manager } = yield* makeManager({
2047 providerScenario: { prListSequence: [[squashMergedPr(branch, headSha)]] },
2048 });
2049
2050 const status = yield* manager.status({ cwd: repoDir });
2051
2052 expect(status.pr?.state).toBe("merged");
2053 expect(status.aheadCount).toBe(1);
2054 expect(status.aheadOfDefaultCount).toBe(2);
2055 }),
2056 );
2057
2058 it.effect("status still reports work against main after a merge into another base", () =>
2059 Effect.gen(function* () {
2060 const repoDir = yield* makeTempDir("t3code-git-manager-");
2061 yield* initRepo(repoDir);
2062 const initialSha = (yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout.trim();
2063 const remoteDir = yield* createBareRemote();
2064 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2065 const branch = "feature/release-only";
2066 const headSha = yield* squashMergeIntoRemoteMain(repoDir, branch);
2067 // Move the merge to release and leave main without it.
2068 const squashSha = (yield* runGit(repoDir, ["rev-parse", "origin/main"])).stdout.trim();
2069 yield* runGit(repoDir, ["push", "origin", `${squashSha}:refs/heads/release`]);
2070 yield* runGit(repoDir, ["push", "--force", "origin", `${initialSha}:refs/heads/main`]);
2071 yield* runGit(repoDir, ["fetch", "origin"]);
2072
2073 const { manager } = yield* makeManager({
2074 providerScenario: {
2075 prListSequence: [[{ ...squashMergedPr(branch, headSha), baseRefName: "release" }]],
2076 },
2077 });
2078
2079 const status = yield* manager.status({ cwd: repoDir });
2080
2081 expect(status.pr?.state).toBe("merged");
2082 expect(status.aheadOfDefaultCount).toBe(1);
2083 }),
2084 );
2085
2086 it.effect("status keeps a squash-merged branch shipped when a later PR lookup fails", () =>
2087 Effect.gen(function* () {
2088 const repoDir = yield* makeTempDir("t3code-git-manager-");
2089 yield* initRepo(repoDir);
2090 const remoteDir = yield* createBareRemote();
2091 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2092 const branch = "feature/squash-lookup-fails";
2093 const headSha = yield* squashMergeIntoRemoteMain(repoDir, branch);
2094 yield* runGit(repoDir, ["push", "origin", "--delete", branch]);
2095 yield* runGit(repoDir, ["fetch", "--prune", "origin"]);
2096
2097 const { manager } = yield* makeManager({
2098 providerScenario: {
2099 prListSequence: [[squashMergedPr(branch, headSha)]],
2100 failWith: "Rate limited",
2101 failAfterCalls: 1,
2102 },
2103 });
2104
2105 const first = yield* manager.status({ cwd: repoDir });
2106 yield* manager.invalidateStatus(repoDir);
2107 const second = yield* manager.status({ cwd: repoDir });
2108
2109 expect(first.aheadOfDefaultCount).toBe(0);
2110 expect(second.pr?.state).toBe("merged");
2111 expect({
2112 aheadCount: second.aheadCount,
2113 aheadOfDefaultCount: second.aheadOfDefaultCount,
2114 }).toEqual({ aheadCount: 0, aheadOfDefaultCount: 0 });
2115 }),
2116 );
2117
2118 it.effect("status keeps real divergence for a squash-merged branch that tracks its base", () =>
2119 Effect.gen(function* () {
2120 const repoDir = yield* makeTempDir("t3code-git-manager-");
2121 yield* initRepo(repoDir);
2122 const remoteDir = yield* createBareRemote();
2123 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2124 const branch = "feature/squash-tracks-main";
2125 const headSha = yield* squashMergeIntoRemoteMain(repoDir, branch);
2126 yield* runGit(repoDir, ["fetch", "origin"]);
2127 yield* runGit(repoDir, ["branch", "--set-upstream-to", "origin/main"]);
2128
2129 const { manager } = yield* makeManager({
2130 providerScenario: { prListSequence: [[squashMergedPr(branch, headSha)]] },
2131 });
2132
2133 const status = yield* manager.status({ cwd: repoDir });
2134
2135 expect(status.pr?.state).toBe("merged");
2136 expect({ aheadCount: status.aheadCount, behindCount: status.behindCount }).toEqual({
2137 aheadCount: 1,
2138 behindCount: 1,
2139 });
2140 }),
2141 );
2142
2143 it.effect("status reports nothing to ship after a squash merge into a non-origin default", () =>
2144 Effect.gen(function* () {
2145 const repoDir = yield* makeTempDir("t3code-git-manager-");
2146 yield* initRepo(repoDir);
2147 yield* runGit(repoDir, ["branch", "-m", "develop"]);
2148 const remoteDir = yield* createBareRemote();
2149 yield* runGit(repoDir, ["remote", "add", "upstream", remoteDir]);
2150 yield* runGit(repoDir, ["push", "-u", "upstream", "develop"]);
2151 yield* runGit(repoDir, ["remote", "set-head", "upstream", "develop"]);
2152 const branch = "feature/squash-develop";
2153 yield* runGit(repoDir, ["checkout", "-b", branch]);
2154 NodeFS.writeFileSync(NodePath.join(repoDir, "squash.txt"), "one\ntwo\n");
2155 yield* runGit(repoDir, ["add", "squash.txt"]);
2156 yield* runGit(repoDir, ["commit", "-m", "Feature work"]);
2157 yield* runGit(repoDir, ["push", "-u", "upstream", branch]);
2158 const headSha = (yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout.trim();
2159 const squash = yield* runGit(repoDir, [
2160 "commit-tree",
2161 "HEAD^{tree}",
2162 "-p",
2163 "upstream/develop",
2164 "-m",
2165 "Feature work (#217)",
2166 ]);
2167 yield* runGit(repoDir, ["push", "upstream", `${squash.stdout.trim()}:refs/heads/develop`]);
2168 yield* runGit(repoDir, ["fetch", "upstream"]);
2169
2170 const { manager } = yield* makeManager({
2171 providerScenario: {
2172 prListSequence: [[{ ...squashMergedPr(branch, headSha), baseRefName: "develop" }]],
2173 },
2174 });
2175
2176 const status = yield* manager.status({ cwd: repoDir });
2177
2178 expect(status.pr?.state).toBe("merged");
2179 expect({
2180 aheadCount: status.aheadCount,
2181 aheadOfDefaultCount: status.aheadOfDefaultCount,
2182 }).toEqual({ aheadCount: 0, aheadOfDefaultCount: 0 });
2183 }),
2184 );
2185
2186 it.each([
2187 [
2188 "https://github.example.com/team/repository/pull/42?tab=files",
2189 "github.example.com/team/repository",
2190 ],
2191 [
2192 "https://gitlab.example.com/group/subgroup/repository/-/merge_requests/42",
2193 "gitlab.example.com/group/subgroup/repository",
2194 ],
2195 ["https://bitbucket.org/team/repository/pull-requests/42", "bitbucket.org/team/repository"],
2196 ["https://codeberg.org/team/repository/pulls/42", "codeberg.org/team/repository"],
2197 [
2198 "http://code.example:3000/forgejo/team/repository/pulls/42/files",
2199 "code.example/forgejo/team/repository",
2200 ],
2201 [
2202 "https://dev.azure.com/org/project/_git/repository/pullrequest/42",
2203 "dev.azure.com/org/project/_git/repository",
2204 ],
2205 [
2206 "https://org.visualstudio.com/project/_git/repository/pullrequest/42",
2207 "org.visualstudio.com/project/_git/repository",
2208 ],
2209 [
2210 "https://gitlab.example/group/pull/123/repository/-/merge_requests/42",
2211 "gitlab.example/group/pull/123/repository",
2212 ],
2213 ["https://github.example.com/team/repository/issues/42", null],
2214 ] as const)("reads the repository from the returned PR URL %s", (url, expected) => {
2215 expect(GitManager.pullRequestRepositoryKey(url)).toBe(expected);
2216 });
2217
2218 it.effect("distinguishes Enterprise forks with the same head branch", () =>
2219 Effect.gen(function* () {
2220 const repoDir = yield* makeTempDir("t3code-git-manager-");
2221 yield* initRepo(repoDir);
2222 const originDir = yield* createBareRemote();
2223 const forkDir = yield* createBareRemote();
2224 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
2225 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2226 yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
2227 yield* runGit(repoDir, ["checkout", "-b", "feature"]);
2228 yield* runGit(repoDir, ["push", "-u", "fork", "feature"]);
2229 yield* configureVisibleRemoteUrlWithLocalRewrite(
2230 repoDir,
2231 "origin",
2232 "git@github.example.com:team/repository.git",
2233 originDir,
2234 );
2235 yield* configureVisibleRemoteUrlWithLocalRewrite(
2236 repoDir,
2237 "fork",
2238 "git@github.example.com:alice/repository.git",
2239 forkDir,
2240 );
2241 const output: FakeChangeRequest[] = [
2242 {
2243 number: 2,
2244 title: "Another fork",
2245 url: "https://github.example.com/team/repository/pull/2",
2246 baseRefName: "main",
2247 headRefName: "feature",
2248 state: "open",
2249 updatedAt: "2026-04-08T15:00:00Z",
2250 isCrossRepository: true,
2251 headRepositoryNameWithOwner: "bob/repository",
2252 headRepositoryOwnerLogin: "bob",
2253 },
2254 {
2255 number: 1,
2256 title: "This fork",
2257 url: "https://github.example.com/team/repository/pull/1",
2258 baseRefName: "main",
2259 headRefName: "feature",
2260 state: "open",
2261 updatedAt: "2026-04-07T15:00:00Z",
2262 isCrossRepository: true,
2263 headRepositoryNameWithOwner: "alice/repository",
2264 headRepositoryOwnerLogin: "alice",
2265 },
2266 ];
2267 const { manager } = yield* makeManager({
2268 providerScenario: {
2269 prListByHeadSelector: {
2270 feature: output,
2271 },
2272 },
2273 });
2274 expect(yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature" })).toMatchObject({
2275 number: 1,
2276 repositoryKey: "github.example.com/team/repository",
2277 });
2278 }),
2279 );
2280
2281 it.effect("finds a fork branch's open PR past a full page of other forks' PRs", () =>
2282 Effect.gen(function* () {
2283 const repoDir = yield* makeTempDir("t3code-git-manager-");
2284 yield* initRepo(repoDir);
2285 const originDir = yield* createBareRemote();
2286 const forkDir = yield* createBareRemote();
2287 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
2288 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2289 yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
2290 yield* runGit(repoDir, ["checkout", "-b", "feature"]);
2291 yield* runGit(repoDir, ["push", "-u", "fork", "feature"]);
2292 yield* configureVisibleRemoteUrlWithLocalRewrite(
2293 repoDir,
2294 "origin",
2295 "git@github.com:team/repository.git",
2296 originDir,
2297 );
2298 yield* configureVisibleRemoteUrlWithLocalRewrite(
2299 repoDir,
2300 "fork",
2301 "git@github.com:alice/repository.git",
2302 forkDir,
2303 );
2304 const otherForks: FakeChangeRequest[] = Array.from({ length: 100 }, (_, index) => ({
2305 number: 200 - index,
2306 title: "Update docs",
2307 url: `https://github.com/team/repository/pull/${200 - index}`,
2308 baseRefName: "main",
2309 headRefName: "feature",
2310 state: "open",
2311 isCrossRepository: true,
2312 headRepositoryNameWithOwner: `fork-${index + 1}/repository`,
2313 headRepositoryOwnerLogin: `fork-${index + 1}`,
2314 }));
2315 const { manager, providerCalls } = yield* makeManager({
2316 providerScenario: {
2317 prListSequenceByHeadSelector: { feature: [otherForks, otherForks] },
2318 prListByHeadSelector: {
2319 "alice:feature": [
2320 {
2321 number: 1,
2322 title: "This fork",
2323 url: "https://github.com/team/repository/pull/1",
2324 baseRefName: "main",
2325 headRefName: "feature",
2326 state: "open",
2327 isCrossRepository: true,
2328 headRepositoryNameWithOwner: "alice/repository",
2329 headRepositoryOwnerLogin: "alice",
2330 },
2331 ],
2332 },
2333 },
2334 });
2335
2336 expect(yield* manager.branchPullRequest({ cwd: repoDir, branch: "feature" })).toMatchObject({
2337 number: 1,
2338 state: "open",
2339 });
2340 expect(listed(providerCalls).map((call) => [call.headSelector, call.state])).toEqual([
2341 ["feature", "all"],
2342 ["alice:feature", "open"],
2343 ]);
2344 }),
2345 );
2346
2347 it.effect.each([
2348 { remoteUrl: "git@gitlab.com:Group/Subgroup/Fork.git", setUpstream: true },
2349 { remoteUrl: "git@gitlab.com:Group/Subgroup/Fork.git", setUpstream: false },
2350 { remoteUrl: "https://gitlab.com/Group/Subgroup/Fork.git", setUpstream: true },
2351 { remoteUrl: "https://gitlab.com/Group/Subgroup/Fork.git", setUpstream: false },
2352 ] as const)(
2353 "matches nested-group forks for $remoteUrl/$setUpstream",
2354 ({ remoteUrl, setUpstream }) =>
2355 Effect.gen(function* () {
2356 const repoDir = yield* makeTempDir("t3code-git-manager-");
2357 yield* initRepo(repoDir);
2358 const originDir = yield* createBareRemote();
2359 const forkDir = yield* createBareRemote();
2360 const branch = "feature/NestedGroups";
2361 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
2362 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2363 yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
2364 yield* runGit(repoDir, ["checkout", "-b", branch]);
2365 yield* runGit(repoDir, ["push", ...(setUpstream ? ["-u"] : []), "fork", branch]);
2366 const upstream = yield* runGit(repoDir, [
2367 "for-each-ref",
2368 "--format=%(upstream:short)",
2369 `refs/heads/${branch}`,
2370 ]);
2371 expect(upstream.stdout.trim()).toBe(setUpstream ? `fork/${branch}` : "");
2372 yield* configureVisibleRemoteUrlWithLocalRewrite(
2373 repoDir,
2374 "origin",
2375 "git@gitlab.com:Group/Upstream/Repository.git",
2376 originDir,
2377 );
2378 yield* configureVisibleRemoteUrlWithLocalRewrite(repoDir, "fork", remoteUrl, forkDir);
2379 const { manager, providerCalls } = yield* makeManager({
2380 providerScenario: {
2381 kind: "gitlab",
2382 headBranchProbe: null,
2383 prListOtherwise: [
2384 {
2385 number: 2,
2386 title: "Another subgroup's fork",
2387 url: "https://gitlab.com/Group/Upstream/Repository/-/merge_requests/2",
2388 baseRefName: "main",
2389 headRefName: branch,
2390 updatedAt: "2026-04-08T15:00:00Z",
2391 isCrossRepository: true,
2392 headRepositoryNameWithOwner: "Group/Other/Fork",
2393 headRepositoryOwnerLogin: "Group",
2394 },
2395 {
2396 number: 1,
2397 title: "This subgroup's fork",
2398 url: "https://gitlab.com/Group/Upstream/Repository/-/merge_requests/1",
2399 baseRefName: "main",
2400 headRefName: branch,
2401 updatedAt: "2026-04-07T15:00:00Z",
2402 isCrossRepository: true,
2403 headRepositoryNameWithOwner: "Group/Subgroup/Fork",
2404 headRepositoryOwnerLogin: "Group",
2405 },
2406 ],
2407 },
2408 });
2409
2410 expect(yield* manager.branchPullRequest({ cwd: repoDir, branch })).toMatchObject({
2411 number: 1,
2412 repositoryKey: "gitlab.com/group/upstream/repository",
2413 });
2414 expect(listed(providerCalls).length).toBeGreaterThan(0);
2415 for (const call of listed(providerCalls)) {
2416 expect(call.headSelector.endsWith(branch)).toBe(true);
2417 expect(call.state).toBe("all");
2418 }
2419 }),
2420 );
2421
2422 it.effect(
2423 "status ignores unrelated fork PRs when the current branch tracks the same repository",
2424 () =>
2425 Effect.gen(function* () {
2426 const repoDir = yield* makeTempDir("t3code-git-manager-");
2427 yield* initRepo(repoDir);
2428 const remoteDir = yield* createBareRemote();
2429 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2430 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2431
2432 const { manager } = yield* makeManager({
2433 providerScenario: {
2434 prListSequence: [
2435 [
2436 {
2437 number: 1661,
2438 title: "Fork PR from main",
2439 url: "https://github.com/pingdotgg/t3code/pull/1661",
2440 baseRefName: "main",
2441 headRefName: "main",
2442 state: "open",
2443 updatedAt: "2026-04-01T15:00:00Z",
2444 isCrossRepository: true,
2445 headRepositoryNameWithOwner: "lnieuwenhuis/t3code",
2446 headRepositoryOwnerLogin: "lnieuwenhuis",
2447 },
2448 ],
2449 ],
2450 },
2451 });
2452
2453 const status = yield* manager.status({ cwd: repoDir });
2454 expect(status.refName).toBe("main");
2455 expect(status.pr).toBeNull();
2456 }),
2457 );
2458
2459 it.effect("status detects cross-repo PRs from the upstream remote URL owner", () =>
2460 Effect.gen(function* () {
2461 const repoDir = yield* makeTempDir("t3code-git-manager-");
2462 yield* initRepo(repoDir);
2463 const forkDir = yield* createBareRemote();
2464 yield* runGit(repoDir, ["remote", "add", "fork-seed", forkDir]);
2465 // Origin is the base repository; a lone remote would be the base itself.
2466 yield* runGit(repoDir, [
2467 "remote",
2468 "add",
2469 "origin",
2470 "git@github.com:pingdotgg/codething-mvp.git",
2471 ]);
2472 yield* runGit(repoDir, ["checkout", "-b", "statemachine"]);
2473 NodeFS.writeFileSync(NodePath.join(repoDir, "fork-pr.txt"), "fork pr\n");
2474 yield* runGit(repoDir, ["add", "fork-pr.txt"]);
2475 yield* runGit(repoDir, ["commit", "-m", "Fork PR branch"]);
2476 yield* runGit(repoDir, ["push", "-u", "fork-seed", "statemachine"]);
2477 yield* runGit(repoDir, ["checkout", "-b", "t3code/pr-488/statemachine"]);
2478 yield* runGit(repoDir, ["branch", "--set-upstream-to", "fork-seed/statemachine"]);
2479 yield* configureVisibleRemoteUrlWithLocalRewrite(
2480 repoDir,
2481 "fork-seed",
2482 "git@github.com:jasonLaster/codething-mvp.git",
2483 forkDir,
2484 );
2485
2486 const { manager, providerCalls } = yield* makeManager({
2487 providerScenario: {
2488 prListSequence: [
2489 [
2490 {
2491 number: 488,
2492 title: "Rebase this PR on latest main",
2493 url: "https://github.com/pingdotgg/codething-mvp/pull/488",
2494 baseRefName: "main",
2495 headRefName: "statemachine",
2496 state: "open",
2497 updatedAt: "2026-03-10T07:00:00Z",
2498 isCrossRepository: true,
2499 headRepositoryNameWithOwner: "jasonLaster/codething-mvp",
2500 headRepositoryOwnerLogin: "jasonLaster",
2501 },
2502 ],
2503 ],
2504 },
2505 });
2506
2507 const status = yield* manager.status({ cwd: repoDir });
2508 expect(status.refName).toBe("t3code/pr-488/statemachine");
2509 expect(status.pr).toEqual({
2510 number: 488,
2511 title: "Rebase this PR on latest main",
2512 url: "https://github.com/pingdotgg/codething-mvp/pull/488",
2513 baseRef: "main",
2514 headRef: "statemachine",
2515 state: "open",
2516 updatedAt: "2026-03-10T07:00:00.000Z",
2517 });
2518 expect(providerCalls).toContainEqual({
2519 operation: "listChangeRequests",
2520 headSelector: "statemachine",
2521 state: "all",
2522 limit: 100,
2523 });
2524 }),
2525 );
2526
2527 it.effect("status preserves a fork PR whose head is named after the default branch", () =>
2528 Effect.gen(function* () {
2529 const repoDir = yield* makeTempDir("t3code-git-manager-");
2530 yield* initRepo(repoDir);
2531 const originDir = yield* createBareRemote();
2532 const forkDir = yield* createBareRemote();
2533 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
2534 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2535 yield* runGit(repoDir, ["remote", "set-head", "origin", "main"]);
2536 yield* runGit(repoDir, ["remote", "add", "fork-seed", forkDir]);
2537 yield* runGit(repoDir, ["push", "fork-seed", "main"]);
2538 yield* runGit(repoDir, ["checkout", "-b", "t3code/pr-777/main"]);
2539 yield* runGit(repoDir, ["branch", "--set-upstream-to", "fork-seed/main"]);
2540 yield* configureVisibleRemoteUrlWithLocalRewrite(
2541 repoDir,
2542 "fork-seed",
2543 "git@github.com:contributor/codething-mvp.git",
2544 forkDir,
2545 );
2546
2547 const { manager, providerCalls } = yield* makeManager({
2548 providerScenario: {
2549 prListByHeadSelector: {
2550 "contributor:main": [
2551 {
2552 number: 777,
2553 title: "Fork PR from main",
2554 url: "https://github.com/pingdotgg/codething-mvp/pull/777",
2555 baseRefName: "main",
2556 headRefName: "main",
2557 state: "open",
2558 updatedAt: "2026-03-10T07:00:00Z",
2559 isCrossRepository: true,
2560 headRepositoryNameWithOwner: "contributor/codething-mvp",
2561 headRepositoryOwnerLogin: "contributor",
2562 },
2563 ],
2564 },
2565 },
2566 });
2567
2568 const status = yield* manager.status({ cwd: repoDir });
2569 expect(status.refName).toBe("t3code/pr-777/main");
2570 expect(status.pr).toEqual({
2571 number: 777,
2572 title: "Fork PR from main",
2573 url: "https://github.com/pingdotgg/codething-mvp/pull/777",
2574 baseRef: "main",
2575 headRef: "main",
2576 state: "open",
2577 updatedAt: "2026-03-10T07:00:00.000Z",
2578 });
2579 expect(providerCalls).toContainEqual({
2580 operation: "listChangeRequests",
2581 headSelector: "contributor:main",
2582 state: "all",
2583 limit: 100,
2584 });
2585 }),
2586 );
2587
2588 it.effect(
2589 "status ignores synthetic local branch aliases when the upstream remote name contains slashes",
2590 () =>
2591 Effect.gen(function* () {
2592 const repoDir = yield* makeTempDir("t3code-git-manager-");
2593 yield* initRepo(repoDir);
2594 const originDir = yield* createBareRemote();
2595 const upstreamDir = yield* createBareRemote();
2596 yield* configureRemote(repoDir, "origin", originDir, "origin");
2597 yield* configureRemote(repoDir, "my-org/upstream", upstreamDir, "my-org/upstream");
2598
2599 yield* runGit(repoDir, ["checkout", "-b", "effect-atom"]);
2600 yield* runGit(repoDir, ["push", "-u", "origin", "effect-atom"]);
2601 yield* runGit(repoDir, ["push", "-u", "my-org/upstream", "effect-atom"]);
2602 yield* configureVisibleRemoteUrlWithLocalRewrite(
2603 repoDir,
2604 "origin",
2605 "git@github.com:pingdotgg/codething-mvp.git",
2606 originDir,
2607 );
2608 yield* runGit(repoDir, ["config", "remote.origin.pushurl", originDir]);
2609 yield* configureVisibleRemoteUrlWithLocalRewrite(
2610 repoDir,
2611 "my-org/upstream",
2612 "ssh://git@github.com/pingdotgg/codething-mvp.git",
2613 upstreamDir,
2614 );
2615 yield* runGit(repoDir, ["config", "remote.my-org/upstream.pushurl", upstreamDir]);
2616 yield* runGit(repoDir, ["checkout", "main"]);
2617 yield* runGit(repoDir, ["branch", "-D", "effect-atom"]);
2618 yield* runGit(repoDir, ["checkout", "--track", "my-org/upstream/effect-atom"]);
2619
2620 const { manager, providerCalls } = yield* makeManager({
2621 providerScenario: {
2622 prListByHeadSelector: {
2623 "effect-atom": [
2624 {
2625 number: 1618,
2626 title: "Correct PR",
2627 url: "https://github.com/pingdotgg/t3code/pull/1618",
2628 baseRefName: "main",
2629 headRefName: "effect-atom",
2630 state: "open",
2631 updatedAt: "2026-03-01T10:00:00Z",
2632 },
2633 ],
2634 "upstream/effect-atom": [
2635 {
2636 number: 1518,
2637 title: "Wrong PR",
2638 url: "https://github.com/pingdotgg/t3code/pull/1518",
2639 baseRefName: "main",
2640 headRefName: "upstream/effect-atom",
2641 state: "open",
2642 updatedAt: "2026-04-01T10:00:00Z",
2643 },
2644 ],
2645 },
2646 },
2647 });
2648
2649 const status = yield* manager.status({ cwd: repoDir });
2650 expect(status.refName).toBe("upstream/effect-atom");
2651 expect(status.pr).toEqual({
2652 number: 1618,
2653 title: "Correct PR",
2654 url: "https://github.com/pingdotgg/t3code/pull/1618",
2655 baseRef: "main",
2656 headRef: "effect-atom",
2657 state: "open",
2658 updatedAt: "2026-03-01T10:00:00.000Z",
2659 });
2660 expect(listedSelectors(providerCalls).includes("upstream/effect-atom")).toBe(false);
2661 expect(listedSelectors(providerCalls).includes("pingdotgg:upstream/effect-atom")).toBe(
2662 false,
2663 );
2664 expect(
2665 listedSelectors(providerCalls).includes("my-org/upstream:upstream/effect-atom"),
2666 ).toBe(false);
2667 }),
2668 );
2669
2670 it.effect("status hides merged PRs on the default branch", () =>
2671 Effect.gen(function* () {
2672 const repoDir = yield* makeTempDir("t3code-git-manager-");
2673 yield* initRepo(repoDir);
2674
2675 const { manager } = yield* makeManager({
2676 providerScenario: {
2677 prListSequence: [
2678 [
2679 {
2680 number: 23,
2681 title: "Merged PR",
2682 url: "https://github.com/pingdotgg/codething-mvp/pull/23",
2683 baseRefName: "feature/status-default-branch-target",
2684 headRefName: "main",
2685 state: "merged",
2686 mergedAt: "2026-01-30T10:00:00Z",
2687 updatedAt: "2026-01-30T10:00:00Z",
2688 },
2689 ],
2690 ],
2691 },
2692 });
2693
2694 const status = yield* manager.status({ cwd: repoDir });
2695 expect(status.refName).toBe("main");
2696 expect(status.pr).toBeNull();
2697 }),
2698 );
2699
2700 it.effect("status does not inherit a merged PR from a feature branch's default upstream", () =>
2701 Effect.gen(function* () {
2702 const repoDir = yield* makeTempDir("t3code-git-manager-");
2703 yield* initRepo(repoDir);
2704 const remoteDir = yield* createBareRemote();
2705 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2706 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2707 yield* runGit(repoDir, ["remote", "set-head", "origin", "main"]);
2708 yield* runGit(repoDir, ["checkout", "-b", "feature/from-main", "origin/main"]);
2709
2710 const { manager, providerCalls } = yield* makeManager({
2711 providerScenario: {
2712 prListSequence: [
2713 [
2714 {
2715 number: 54,
2716 title: "Reverse merge from main",
2717 url: "https://github.com/pingdotgg/codething-mvp/pull/54",
2718 baseRefName: "je-filter-list",
2719 headRefName: "main",
2720 state: "merged",
2721 mergedAt: "2023-09-28T03:21:10Z",
2722 updatedAt: "2023-09-28T03:21:10Z",
2723 },
2724 ],
2725 ],
2726 },
2727 });
2728
2729 const status = yield* manager.status({ cwd: repoDir });
2730 expect(status.refName).toBe("feature/from-main");
2731 expect(status.pr).toBeNull();
2732 expect(listed(providerCalls).length > 0).toBe(false);
2733 }),
2734 );
2735
2736 it.effect("branch PR lookup in a fork checkout follows the branch's own published ref", () =>
2737 Effect.gen(function* () {
2738 const repoDir = yield* makeTempDir("t3code-git-manager-");
2739 yield* initRepo(repoDir);
2740 const forkDir = yield* createBareRemote();
2741 yield* runGit(repoDir, ["remote", "add", "origin", forkDir]);
2742 yield* runGit(repoDir, [
2743 "remote",
2744 "add",
2745 "upstream",
2746 "git@github.com:pingdotgg/codething-mvp.git",
2747 ]);
2748 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2749 yield* runGit(repoDir, ["remote", "set-head", "origin", "main"]);
2750 // What a new worktree thread gets: its start point as upstream, nothing published.
2751 yield* runGit(repoDir, ["branch", "--track", "t3code/new-thread", "origin/main"]);
2752 yield* runGit(repoDir, ["branch", "--track", "feature/published", "origin/main"]);
2753 yield* runGit(repoDir, ["branch", "--track", "t3code/pr-300/main", "origin/main"]);
2754 yield* runGit(repoDir, ["push", "origin", "feature/published"]);
2755 yield* configureVisibleRemoteUrlWithLocalRewrite(
2756 repoDir,
2757 "origin",
2758 "git@github.com:contributor/codething-mvp.git",
2759 forkDir,
2760 );
2761
2762 const forkPullRequest = {
2763 baseRefName: "main",
2764 isCrossRepository: true,
2765 headRepositoryNameWithOwner: "contributor/codething-mvp",
2766 headRepositoryOwnerLogin: "contributor",
2767 } as const;
2768 const { service, calls } = createFakeSourceControlProvider({
2769 prListByHeadSelector: {
2770 "contributor:main": [
2771 {
2772 ...forkPullRequest,
2773 number: 300,
2774 title: "Fork main",
2775 url: "https://github.com/pingdotgg/codething-mvp/pull/300",
2776 headRefName: "main",
2777 state: "merged",
2778 },
2779 ],
2780 "feature/published": [
2781 {
2782 ...forkPullRequest,
2783 number: 224,
2784 title: "Fork feature",
2785 url: "https://github.com/pingdotgg/codething-mvp/pull/224",
2786 headRefName: "feature/published",
2787 state: "open",
2788 },
2789 ],
2790 },
2791 });
2792 const { manager } = yield* makeManager({
2793 sourceControlProvider: {
2794 ...service,
2795 createsChangeRequestsIn: ({ repository }) =>
2796 Effect.succeed(repository === "pingdotgg/codething-mvp"),
2797 },
2798 });
2799
2800 const unpublished = yield* manager.branchPullRequest({
2801 cwd: repoDir,
2802 branch: "t3code/new-thread",
2803 });
2804 expect(unpublished).toBeNull();
2805 expect(listedSelectors(calls)).toEqual([]);
2806
2807 const published = yield* manager.branchPullRequest({
2808 cwd: repoDir,
2809 branch: "feature/published",
2810 });
2811 expect(published?.number).toBe(224);
2812
2813 const pullRequestWorktree = yield* manager.branchPullRequest({
2814 cwd: repoDir,
2815 branch: "t3code/pr-300/main",
2816 });
2817 expect(pullRequestWorktree?.number).toBe(300);
2818 }),
2819 );
2820
2821 it.effect("branch PR lookup ignores the PR of a local branch the branch tracks", () =>
2822 Effect.gen(function* () {
2823 const repoDir = yield* makeTempDir("t3code-git-manager-");
2824 yield* initRepo(repoDir);
2825 const remoteDir = yield* createBareRemote();
2826 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2827 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2828 yield* runGit(repoDir, ["remote", "set-head", "origin", "main"]);
2829 yield* runGit(repoDir, ["checkout", "-b", "develop"]);
2830 yield* runGit(repoDir, ["push", "-u", "origin", "develop"]);
2831 // `--track` from a local branch, or `branch.autoSetupMerge=always`, records remote ".".
2832 yield* runGit(repoDir, ["checkout", "-b", "feature/local-base", "--track", "develop"]);
2833
2834 const { manager, providerCalls } = yield* makeManager({
2835 providerScenario: {
2836 prListByHeadSelector: {
2837 develop: [
2838 {
2839 number: 61,
2840 title: "Release develop",
2841 url: "https://github.com/pingdotgg/codething-mvp/pull/61",
2842 baseRefName: "main",
2843 headRefName: "develop",
2844 state: "open",
2845 updatedAt: "2026-05-01T10:00:00Z",
2846 },
2847 ],
2848 // Someone else's branch of the same name; this one was never pushed.
2849 "feature/local-base": [
2850 {
2851 number: 62,
2852 title: "Another local base",
2853 url: "https://github.com/pingdotgg/codething-mvp/pull/62",
2854 baseRefName: "main",
2855 headRefName: "feature/local-base",
2856 state: "open",
2857 updatedAt: "2026-05-01T10:00:00Z",
2858 },
2859 ],
2860 },
2861 },
2862 });
2863
2864 const status = yield* manager.status({ cwd: repoDir });
2865 expect(status.refName).toBe("feature/local-base");
2866 expect(status.pr).toBeNull();
2867 expect(listedSelectors(providerCalls).includes("develop")).toBe(false);
2868
2869 const branchPullRequest = yield* manager.branchPullRequest({
2870 cwd: repoDir,
2871 branch: "feature/local-base",
2872 });
2873 expect(branchPullRequest).toBeNull();
2874 }),
2875 );
2876
2877 it.effect(
2878 "status does not inherit a release PR from a worktree's non-default base upstream",
2879 () =>
2880 Effect.gen(function* () {
2881 const repoDir = yield* makeTempDir("t3code-git-manager-");
2882 yield* initRepo(repoDir);
2883 const remoteDir = yield* createBareRemote();
2884 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2885 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2886 yield* runGit(repoDir, ["push", "origin", "main:dev"]);
2887 yield* runGit(repoDir, ["fetch", "origin"]);
2888 yield* runGit(repoDir, ["remote", "set-head", "origin", "main"]);
2889 yield* runGit(repoDir, ["checkout", "-b", "feature/from-dev", "origin/dev"]);
2890 yield* runGit(repoDir, ["config", "branch.feature/from-dev.t3-merge-base", "dev"]);
2891
2892 const { manager, providerCalls } = yield* makeManager({
2893 providerScenario: {
2894 prListByHeadSelector: {
2895 dev: [
2896 {
2897 number: 49,
2898 title: "Release dev to main",
2899 url: "https://github.com/pingdotgg/codething-mvp/pull/49",
2900 baseRefName: "main",
2901 headRefName: "dev",
2902 state: "merged",
2903 updatedAt: "2026-08-20T10:00:00Z",
2904 },
2905 ],
2906 },
2907 },
2908 });
2909
2910 const status = yield* manager.status({ cwd: repoDir });
2911 expect(status.refName).toBe("feature/from-dev");
2912 expect(status.pr).toBeNull();
2913 expect(listedSelectors(providerCalls).includes("dev")).toBe(false);
2914 }),
2915 );
2916
2917 it.effect("status finds a PR pushed under the branch's own name despite a default upstream", () =>
2918 Effect.gen(function* () {
2919 const repoDir = yield* makeTempDir("t3code-git-manager-");
2920 yield* initRepo(repoDir);
2921 const remoteDir = yield* createBareRemote();
2922 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
2923 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2924 yield* runGit(repoDir, ["remote", "set-head", "origin", "main"]);
2925 yield* runGit(repoDir, ["checkout", "-b", "feature/pushed-plain", "origin/main"]);
2926 yield* runGit(repoDir, ["push", "origin", "feature/pushed-plain"]);
2927
2928 const { manager, providerCalls } = yield* makeManager({
2929 providerScenario: {
2930 prListByHeadSelector: {
2931 "feature/pushed-plain": [
2932 {
2933 number: 88,
2934 title: "Pushed without -u",
2935 url: "https://github.com/pingdotgg/codething-mvp/pull/88",
2936 baseRefName: "main",
2937 headRefName: "feature/pushed-plain",
2938 state: "open",
2939 updatedAt: "2026-05-01T10:00:00Z",
2940 },
2941 ],
2942 },
2943 },
2944 });
2945
2946 const status = yield* manager.status({ cwd: repoDir });
2947 expect(status.refName).toBe("feature/pushed-plain");
2948 expect(status.pr?.number).toBe(88);
2949 expect(listedSelectors(providerCalls).includes("main")).toBe(false);
2950 }),
2951 );
2952
2953 it.effect(
2954 "status finds a fork PR pushed under the branch's own name despite a default upstream",
2955 () =>
2956 Effect.gen(function* () {
2957 const repoDir = yield* makeTempDir("t3code-git-manager-");
2958 yield* initRepo(repoDir);
2959 const originDir = yield* createBareRemote();
2960 const forkDir = yield* createBareRemote();
2961 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
2962 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
2963 yield* runGit(repoDir, ["remote", "set-head", "origin", "main"]);
2964 yield* configureRemote(repoDir, "team/fork", forkDir, "team/fork");
2965 yield* runGit(repoDir, ["checkout", "-b", "feature/fork-plain", "origin/main"]);
2966 yield* runGit(repoDir, ["push", "team/fork", "feature/fork-plain"]);
2967 yield* configureVisibleRemoteUrlWithLocalRewrite(
2968 repoDir,
2969 "origin",
2970 "git@github.com:pingdotgg/codething-mvp.git",
2971 originDir,
2972 );
2973 yield* configureVisibleRemoteUrlWithLocalRewrite(
2974 repoDir,
2975 "team/fork",
2976 "git@github.com:contributor/codething-mvp.git",
2977 forkDir,
2978 );
2979
2980 const { manager, providerCalls } = yield* makeManager({
2981 providerScenario: {
2982 prListByHeadSelector: {
2983 "feature/fork-plain": [
2984 {
2985 number: 89,
2986 title: "Fork PR pushed without -u",
2987 url: "https://github.com/pingdotgg/codething-mvp/pull/89",
2988 baseRefName: "main",
2989 headRefName: "feature/fork-plain",
2990 state: "open",
2991 updatedAt: "2026-05-01T10:00:00Z",
2992 isCrossRepository: true,
2993 headRepositoryNameWithOwner: "contributor/codething-mvp",
2994 headRepositoryOwnerLogin: "contributor",
2995 },
2996 ],
2997 },
2998 },
2999 });
3000
3001 const status = yield* manager.status({ cwd: repoDir });
3002 expect(status.pr?.number).toBe(89);
3003 expect(listedSelectors(providerCalls).includes("feature/fork-plain")).toBe(true);
3004 expect(
3005 listedSelectors(providerCalls).some((selector) => selector.startsWith("contributor:")),
3006 ).toBe(false);
3007 expect(listedSelectors(providerCalls).includes("main")).toBe(false);
3008 }),
3009 );
3010
3011 it.effect("status prefers open PR when merged PR has newer updatedAt", () =>
3012 Effect.gen(function* () {
3013 const repoDir = yield* makeTempDir("t3code-git-manager-");
3014 yield* initRepo(repoDir);
3015 yield* runGit(repoDir, ["checkout", "-b", "feature/status-open-over-merged"]);
3016
3017 const { manager } = yield* makeManager({
3018 providerScenario: {
3019 prListSequence: [
3020 [
3021 {
3022 number: 45,
3023 title: "Merged PR",
3024 url: "https://github.com/pingdotgg/codething-mvp/pull/45",
3025 baseRefName: "main",
3026 headRefName: "feature/status-open-over-merged",
3027 state: "merged",
3028 mergedAt: "2026-01-31T10:00:00Z",
3029 updatedAt: "2026-02-01T10:00:00Z",
3030 },
3031 {
3032 number: 46,
3033 title: "Open PR",
3034 url: "https://github.com/pingdotgg/codething-mvp/pull/46",
3035 baseRefName: "main",
3036 headRefName: "feature/status-open-over-merged",
3037 state: "open",
3038 updatedAt: "2026-01-30T10:00:00Z",
3039 },
3040 ],
3041 ],
3042 },
3043 });
3044
3045 const status = yield* manager.status({ cwd: repoDir });
3046 expect(status.refName).toBe("feature/status-open-over-merged");
3047 expect(status.pr).toEqual({
3048 number: 46,
3049 title: "Open PR",
3050 url: "https://github.com/pingdotgg/codething-mvp/pull/46",
3051 baseRef: "main",
3052 headRef: "feature/status-open-over-merged",
3053 state: "open",
3054 updatedAt: "2026-01-30T10:00:00.000Z",
3055 });
3056 }),
3057 );
3058
3059 it.effect("status keeps the last known PR when a later lookup fails", () =>
3060 Effect.gen(function* () {
3061 const repoDir = yield* makeTempDir("t3code-git-manager-");
3062 yield* initRepo(repoDir);
3063 yield* runGit(repoDir, ["checkout", "-b", "feature/pr-sticky"]);
3064 const remoteDir = yield* createBareRemote();
3065 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3066 yield* runGit(repoDir, ["push", "-u", "origin", "feature/pr-sticky"]);
3067
3068 const existingPr = {
3069 number: 214,
3070 title: "Sticky PR",
3071 url: "https://github.com/pingdotgg/codething-mvp/pull/214",
3072 baseRefName: "main",
3073 headRefName: "feature/pr-sticky",
3074 };
3075 const { manager } = yield* makeManager({
3076 providerScenario: {
3077 prListSequence: [[existingPr]],
3078 failWith: "The host is signed out.",
3079 failAfterCalls: 1,
3080 },
3081 });
3082
3083 const first = yield* manager.status({ cwd: repoDir });
3084 expect(first.pr?.number).toBe(214);
3085
3086 yield* manager.invalidateStatus(repoDir);
3087 const second = yield* manager.status({ cwd: repoDir });
3088 expect(second.pr?.number).toBe(214);
3089 }),
3090 );
3091
3092 it.effect(
3093 "status does not reuse a stale PR after the branch is retargeted to a different upstream",
3094 () =>
3095 Effect.gen(function* () {
3096 const repoDir = yield* makeTempDir("t3code-git-manager-");
3097 yield* initRepo(repoDir);
3098 yield* runGit(repoDir, ["checkout", "-b", "feature/pr-retarget"]);
3099
3100 const originRemote = yield* createBareRemote();
3101 yield* runGit(repoDir, ["remote", "add", "origin", originRemote]);
3102 yield* runGit(repoDir, ["push", "-u", "origin", "feature/pr-retarget"]);
3103
3104 const existingPr = {
3105 number: 214,
3106 title: "Sticky PR",
3107 url: "https://github.com/pingdotgg/codething-mvp/pull/214",
3108 baseRefName: "main",
3109 headRefName: "feature/pr-retarget",
3110 };
3111 const { manager } = yield* makeManager({
3112 providerScenario: {
3113 prListSequence: [[existingPr]],
3114 failWith: "The host is signed out.",
3115 failAfterCalls: 1,
3116 },
3117 });
3118
3119 const first = yield* manager.status({ cwd: repoDir });
3120 expect(first.pr?.number).toBe(214);
3121
3122 const forkRemote = yield* createBareRemote();
3123 yield* runGit(repoDir, ["remote", "add", "fork", forkRemote]);
3124 yield* runGit(repoDir, ["push", "fork", "feature/pr-retarget"]);
3125 yield* runGit(repoDir, [
3126 "branch",
3127 "--set-upstream-to=fork/feature/pr-retarget",
3128 "feature/pr-retarget",
3129 ]);
3130
3131 yield* manager.invalidateStatus(repoDir);
3132 const second = yield* manager.status({ cwd: repoDir });
3133 expect(second.pr).toBeNull();
3134 }),
3135 );
3136
3137 it.effect("creates a commit when working tree is dirty", () =>
3138 Effect.gen(function* () {
3139 const repoDir = yield* makeTempDir("t3code-git-manager-");
3140 yield* initRepo(repoDir);
3141 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nworld\n");
3142 let generatedPolicy: TextGeneration.CommitMessageGenerationInput["policy"] = undefined;
3143
3144 const { manager } = yield* makeManager({
3145 serverSettings: {
3146 sourceControlWritingStyle: {
3147 mode: "custom" as const,
3148 customInstructions: "Use a direct tone.",
3149 },
3150 },
3151 textGeneration: {
3152 generateCommitMessage: (input) => {
3153 generatedPolicy = input.policy;
3154 return Effect.succeed({ subject: "Implement stacked git actions", body: "" });
3155 },
3156 },
3157 });
3158 const result = yield* runStackedAction(manager, {
3159 cwd: repoDir,
3160 action: "commit",
3161 });
3162
3163 expect(result.branch.status).toBe("skipped_not_requested");
3164 expect(result.commit.status).toBe("created");
3165 expect(result.push.status).toBe("skipped_not_requested");
3166 expect(result.pr.status).toBe("skipped_not_requested");
3167 expect(generatedPolicy).toMatchObject({ commitInstructions: "Use a direct tone." });
3168 expect(result.toast).toMatchObject({
3169 description: "Implement stacked git actions",
3170 cta: {
3171 kind: "run_action",
3172 label: "Push",
3173 action: {
3174 kind: "push",
3175 },
3176 },
3177 });
3178 expect(result.toast.title).toMatch(/^Committed [0-9a-f]{7}$/);
3179 expect(
3180 yield* runGit(repoDir, ["log", "-1", "--pretty=%s"]).pipe(
3181 Effect.map((result) => result.stdout.trim()),
3182 ),
3183 ).toBe("Implement stacked git actions");
3184 }),
3185 );
3186
3187 it.effect("lowercases a capitalized Conventional Commits description", () =>
3188 Effect.gen(function* () {
3189 const repoDir = yield* makeTempDir("t3code-git-manager-");
3190 yield* initRepo(repoDir);
3191 const subjects = ["ci: Run E2E on pull requests", "feat(web)!: A new layout"];
3192 const queued = [...subjects];
3193
3194 const { manager } = yield* makeManager({
3195 serverSettings: { sourceControlWritingStyle: { mode: "conventional_commits" as const } },
3196 textGeneration: {
3197 generateCommitMessage: () => Effect.succeed({ subject: queued.shift() ?? "", body: "" }),
3198 },
3199 });
3200
3201 const committed: Array<string> = [];
3202 for (const [index] of subjects.entries()) {
3203 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), `change ${index}\n`);
3204 yield* runStackedAction(manager, { cwd: repoDir, action: "commit" });
3205 committed.push((yield* runGit(repoDir, ["log", "-1", "--pretty=%s"])).stdout.trim());
3206 }
3207
3208 expect(committed).toEqual(["ci: run E2E on pull requests", "feat(web)!: a new layout"]);
3209 }),
3210 );
3211
3212 it.effect("includes CLAUDE.md for Claude writers only when it differs from AGENTS.md", () =>
3213 Effect.gen(function* () {
3214 const repoDir = yield* makeTempDir("t3code-git-manager-");
3215 yield* initRepo(repoDir);
3216 NodeFS.writeFileSync(NodePath.join(repoDir, "AGENTS.md"), "Use imperative subjects.\n");
3217 NodeFS.copyFileSync(NodePath.join(repoDir, "AGENTS.md"), NodePath.join(repoDir, "CLAUDE.md"));
3218 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\n");
3219 const commitInstructions: Array<string | undefined> = [];
3220
3221 const { manager } = yield* makeManager({
3222 serverSettings: {
3223 textGenerationModelSelection: {
3224 instanceId: ProviderInstanceId.make("claudeAgent"),
3225 model: "claude-sonnet-4-5",
3226 },
3227 },
3228 textGeneration: {
3229 generateCommitMessage: (input) => {
3230 commitInstructions.push(input.policy?.commitInstructions);
3231 return Effect.succeed({ subject: "Update readme", body: "" });
3232 },
3233 },
3234 });
3235
3236 yield* runStackedAction(manager, { cwd: repoDir, action: "commit" });
3237
3238 NodeFS.writeFileSync(NodePath.join(repoDir, "CLAUDE.md"), "Mention the Claude provider.\n");
3239 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello again\n");
3240 yield* runStackedAction(manager, { cwd: repoDir, action: "commit" });
3241
3242 expect(commitInstructions[0]).toContain("Local AGENTS.md:\nUse imperative subjects.");
3243 expect(commitInstructions[0]).not.toContain("Local CLAUDE.md:");
3244 expect(commitInstructions[1]).toContain("Local CLAUDE.md:\nMention the Claude provider.");
3245 }),
3246 );
3247
3248 it.effect("keeps signature output out of recent commit subjects", () =>
3249 Effect.gen(function* () {
3250 const repoDir = yield* makeTempDir("t3code-git-manager-");
3251 yield* initRepo(repoDir);
3252 const signingKey = NodePath.join(yield* makeTempDir("t3code-git-signing-key-"), "key");
3253 NodeChildProcess.execFileSync("ssh-keygen", [
3254 "-q",
3255 "-t",
3256 "ed25519",
3257 "-N",
3258 "",
3259 "-f",
3260 signingKey,
3261 ]);
3262 yield* runGit(repoDir, ["config", "gpg.format", "ssh"]);
3263 // A global signer such as 1Password's cannot use the fixture's generated key.
3264 yield* runGit(repoDir, ["config", "gpg.ssh.program", "ssh-keygen"]);
3265 yield* runGit(repoDir, ["config", "user.signingkey", `${signingKey}.pub`]);
3266 yield* runGit(repoDir, ["config", "log.showSignature", "true"]);
3267 yield* runGit(repoDir, ["commit", "--amend", "-S", "--no-edit"]);
3268 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello again\n");
3269 let commitInstructions: string | undefined;
3270
3271 const { manager } = yield* makeManager({
3272 textGeneration: {
3273 generateCommitMessage: (input) => {
3274 commitInstructions = input.policy?.commitInstructions;
3275 return Effect.succeed({ subject: "Update readme", body: "" });
3276 },
3277 },
3278 });
3279
3280 yield* runStackedAction(manager, { cwd: repoDir, action: "commit" });
3281
3282 expect(commitInstructions).toMatch(
3283 /Recent commit subjects from this repository:\nInitial commit$/,
3284 );
3285 }),
3286 );
3287
3288 it.effect("falls back when the dedicated source control writer is unavailable", () =>
3289 Effect.gen(function* () {
3290 const repoDir = yield* makeTempDir("t3code-git-manager-");
3291 yield* initRepo(repoDir);
3292 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nworld\n");
3293 const missingInstanceId = ProviderInstanceId.make("missing_writer");
3294 let generatedModelSelection:
3295 | TextGeneration.CommitMessageGenerationInput["modelSelection"]
3296 | undefined;
3297
3298 const { manager } = yield* makeManager({
3299 serverSettings: {
3300 providerInstances: {
3301 [missingInstanceId]: {
3302 driver: ProviderDriverKind.make("missing-driver"),
3303 config: {},
3304 },
3305 },
3306 sourceControlWriterModelSelection: {
3307 instanceId: missingInstanceId,
3308 model: "missing-model",
3309 },
3310 },
3311 textGeneration: {
3312 generateCommitMessage: (input) => {
3313 generatedModelSelection = input.modelSelection;
3314 return Effect.succeed({ subject: "Use the available writer", body: "" });
3315 },
3316 },
3317 });
3318
3319 yield* runStackedAction(manager, {
3320 cwd: repoDir,
3321 action: "commit",
3322 });
3323
3324 expect(generatedModelSelection).toEqual(DEFAULT_SERVER_SETTINGS.textGenerationModelSelection);
3325 }),
3326 );
3327
3328 it.effect("uses an explicit project's provider settings for generated commit text", () =>
3329 Effect.gen(function* () {
3330 const repoDir = yield* makeTempDir("t3code-git-manager-");
3331 yield* initRepo(repoDir);
3332 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nproject\n");
3333 const projectId = ProjectId.make("project:git-action-settings");
3334 const disabledInstanceId = DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.instanceId;
3335 let generatedModelSelection:
3336 | TextGeneration.CommitMessageGenerationInput["modelSelection"]
3337 | undefined;
3338
3339 const { manager } = yield* makeManager({
3340 serverSettings: {
3341 projectSettingsOverrides: {
3342 [projectId]: {
3343 providerInstances: { [disabledInstanceId]: { enabled: false } },
3344 },
3345 },
3346 },
3347 textGeneration: {
3348 generateCommitMessage: (input) => {
3349 generatedModelSelection = input.modelSelection;
3350 return Effect.succeed({ subject: "Use the project writer", body: "" });
3351 },
3352 },
3353 });
3354
3355 yield* manager.runStackedAction({
3356 actionId: "test-project-action-settings",
3357 cwd: repoDir,
3358 action: "commit",
3359 projectId,
3360 });
3361
3362 expect(generatedModelSelection?.instanceId).toBe(ProviderInstanceId.make("claudeAgent"));
3363 }),
3364 );
3365
3366 it.effect("prefers a V2-native thread's project settings over an explicit project", () =>
3367 Effect.gen(function* () {
3368 const repoDir = yield* makeTempDir("t3code-git-manager-");
3369 yield* initRepo(repoDir);
3370 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nproject\n");
3371 const projectId = ProjectId.make("project:git-settings");
3372 const threadId = ThreadId.make("thread:git-settings");
3373 const projectModel: ModelSelection = {
3374 instanceId: ProviderInstanceId.make("codex"),
3375 model: "gpt-project-writer",
3376 };
3377 const providerInstanceId = ProviderInstanceId.make("codex");
3378 const createdAt = DateTime.makeUnsafe("2026-09-27T00:00:00.000Z");
3379 let generatedModelSelection:
3380 | TextGeneration.CommitMessageGenerationInput["modelSelection"]
3381 | undefined;
3382
3383 const { manager } = yield* makeManager({
3384 serverSettings: {
3385 projectSettingsOverrides: { [projectId]: { textGenerationModelSelection: projectModel } },
3386 },
3387 textGeneration: {
3388 generateCommitMessage: (input) => {
3389 generatedModelSelection = input.modelSelection;
3390 return Effect.succeed({ subject: "Use the project writer", body: "" });
3391 },
3392 },
3393 seed: Effect.gen(function* () {
3394 yield* (yield* ProjectStore.ProjectStoreV2).apply({
3395 sequence: 1,
3396 eventId: EventId.make("event:git-settings:project"),
3397 aggregateKind: "project",
3398 aggregateId: projectId,
3399 occurredAt: DateTime.formatIso(createdAt),
3400 commandId: null,
3401 causationEventId: null,
3402 correlationId: null,
3403 metadata: {},
3404 type: "project.created",
3405 payload: {
3406 projectId,
3407 title: "Git settings",
3408 workspaceRoot: "/elsewhere",
3409 defaultModelSelection: null,
3410 scripts: [],
3411 createdAt: DateTime.formatIso(createdAt),
3412 updatedAt: DateTime.formatIso(createdAt),
3413 },
3414 });
3415 yield* (yield* ProjectionStore.ProjectionStoreV2).apply({
3416 id: EventId.make("event:git-settings:thread"),
3417 type: "thread.created",
3418 threadId,
3419 providerInstanceId,
3420 occurredAt: createdAt,
3421 payload: {
3422 createdBy: "user",
3423 creationSource: "web",
3424 id: threadId,
3425 projectId,
3426 title: "Git settings",
3427 providerInstanceId,
3428 modelSelection: { instanceId: providerInstanceId, model: "gpt-5" },
3429 runtimeMode: "full-access",
3430 interactionMode: "default",
3431 branch: null,
3432 worktreePath: repoDir,
3433 activeProviderThreadId: null,
3434 lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
3435 forkedFrom: null,
3436 createdAt,
3437 updatedAt: createdAt,
3438 archivedAt: null,
3439 settledOverride: null,
3440 settledAt: null,
3441 lastVisitedAt: null,
3442 deletedAt: null,
3443 },
3444 });
3445 }),
3446 });
3447
3448 yield* manager.runStackedAction({
3449 actionId: "test-action-id",
3450 cwd: repoDir,
3451 action: "commit",
3452 threadId,
3453 projectId: ProjectId.make("project:other"),
3454 });
3455
3456 expect(generatedModelSelection).toEqual(projectModel);
3457 }),
3458 );
3459
3460 it.effect.each([undefined, ["README.md"]])(
3461 "a failed generation preserves staging changed while generating (paths: %s)",
3462 (filePaths) =>
3463 Effect.gen(function* () {
3464 const repoDir = yield* makeTempDir("t3code-git-manager-");
3465 yield* initRepo(repoDir);
3466 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nstaged\n");
3467 yield* runGit(repoDir, ["add", "README.md"]);
3468 NodeFS.appendFileSync(NodePath.join(repoDir, "README.md"), "unstaged\n");
3469 NodeFS.writeFileSync(NodePath.join(repoDir, "untracked.txt"), "untracked\n");
3470 const indexBefore = NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"));
3471 const headBefore = (yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout;
3472 const gitDriver = yield* GitVcsDriver.GitVcsDriver;
3473 let indexDuring: Buffer | undefined;
3474 let indexAfterUserStage: Buffer | undefined;
3475 const { manager } = yield* makeManager({
3476 textGeneration: {
3477 generateCommitMessage: () =>
3478 Effect.gen(function* () {
3479 indexDuring = NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"));
3480 yield* runGit(repoDir, ["add", "untracked.txt"]).pipe(
3481 Effect.provideService(GitVcsDriver.GitVcsDriver, gitDriver),
3482 Effect.orDie,
3483 );
3484 indexAfterUserStage = NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"));
3485 return yield* new TextGenerationError({
3486 operation: "generateCommitMessage",
3487 detail: "Provider rejected generation",
3488 });
3489 }),
3490 },
3491 });
3492 const result = yield* runStackedAction(manager, {
3493 cwd: repoDir,
3494 action: "commit",
3495 ...(filePaths ? { filePaths } : {}),
3496 }).pipe(Effect.result);
3497 expect(Result.isFailure(result)).toBe(true);
3498 expect(indexDuring).toEqual(indexBefore);
3499 expect(NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"))).toEqual(
3500 indexAfterUserStage,
3501 );
3502 expect((yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout).toBe(headBefore);
3503 expect((yield* runGit(repoDir, ["diff"])).stdout).toContain("+unstaged");
3504 }),
3505 );
3506
3507 it.effect("commits only selected files when filePaths is provided", () =>
3508 Effect.gen(function* () {
3509 const repoDir = yield* makeTempDir("t3code-git-manager-");
3510 yield* initRepo(repoDir);
3511 NodeFS.writeFileSync(NodePath.join(repoDir, "a.txt"), "file a\n");
3512 NodeFS.writeFileSync(NodePath.join(repoDir, "b.txt"), "file b\n");
3513
3514 const { manager } = yield* makeManager();
3515 const result = yield* runStackedAction(manager, {
3516 cwd: repoDir,
3517 action: "commit",
3518 filePaths: ["a.txt"],
3519 });
3520
3521 expect(result.commit.status).toBe("created");
3522
3523 const statusStdout = yield* runGit(repoDir, ["status", "--porcelain"]).pipe(
3524 Effect.map((r) => r.stdout),
3525 );
3526 expect(statusStdout).toContain("b.txt");
3527 expect(statusStdout).not.toContain("a.txt");
3528 }),
3529 );
3530
3531 it.effect("creates feature branch, commits, and pushes with featureBranch option", () =>
3532 Effect.gen(function* () {
3533 const repoDir = yield* makeTempDir("t3code-git-manager-");
3534 yield* initRepo(repoDir);
3535 const remoteDir = yield* createBareRemote();
3536 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3537 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
3538 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nfeature-branch\n");
3539 let generatedCount = 0;
3540
3541 const { manager } = yield* makeManager({
3542 textGeneration: {
3543 generateCommitMessage: (input) =>
3544 Effect.sync(() => {
3545 generatedCount += 1;
3546 return {
3547 subject: "Implement stacked git actions",
3548 body: "",
3549 ...(input.includeBranch ? { branch: "feature/implement-stacked-git-actions" } : {}),
3550 };
3551 }),
3552 },
3553 });
3554 const result = yield* runStackedAction(manager, {
3555 cwd: repoDir,
3556 action: "commit_push",
3557 featureBranch: true,
3558 });
3559
3560 expect(result.branch.status).toBe("created");
3561 expect(result.branch.name).toBe("feature/implement-stacked-git-actions");
3562 expect(result.commit.status).toBe("created");
3563 expect(result.push.status).toBe("pushed");
3564 expect(result.toast).toMatchObject({
3565 description: "Implement stacked git actions",
3566 cta: {
3567 kind: "run_action",
3568 label: "Create PR",
3569 action: {
3570 kind: "create_pr",
3571 },
3572 },
3573 });
3574 expect(result.toast.title).toMatch(
3575 /^Pushed [0-9a-f]{7} to origin\/feature\/implement-stacked-git-actions$/,
3576 );
3577 expect(
3578 yield* runGit(repoDir, ["rev-parse", "--abbrev-ref", "HEAD"]).pipe(
3579 Effect.map((result) => result.stdout.trim()),
3580 ),
3581 ).toBe("feature/implement-stacked-git-actions");
3582
3583 const mainSha = yield* runGit(repoDir, ["rev-parse", "main"]).pipe(
3584 Effect.map((r) => r.stdout.trim()),
3585 );
3586 const mergeBase = yield* runGit(repoDir, ["merge-base", "main", "HEAD"]).pipe(
3587 Effect.map((r) => r.stdout.trim()),
3588 );
3589 expect(mergeBase).toBe(mainSha);
3590 expect(generatedCount).toBe(1);
3591 }),
3592 );
3593
3594 it.effect.each([
3595 { branch: "fix/name", existingBranches: ["fix"], expected: "fix-2/name" },
3596 { branch: "fix/name", existingBranches: ["fix/name/child"], expected: "fix/name-2" },
3597 ])("commits on $expected when $branch has ref namespace collisions", (scenario) =>
3598 Effect.gen(function* () {
3599 const repoDir = yield* makeTempDir("t3code-git-manager-");
3600 yield* initRepo(repoDir);
3601 const mainSha = (yield* runGit(repoDir, ["rev-parse", "main"])).stdout.trim();
3602 for (const branch of scenario.existingBranches) {
3603 yield* runGit(repoDir, ["branch", branch]);
3604 }
3605 NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nnamespace-collision\n");
3606
3607 const { manager } = yield* makeManager({
3608 textGeneration: {
3609 generateCommitMessage: () =>
3610 Effect.succeed({
3611 subject: "Fix namespace collision",
3612 body: "",
3613 branch: scenario.branch,
3614 }),
3615 },
3616 });
3617 const result = yield* runStackedAction(manager, {
3618 cwd: repoDir,
3619 action: "commit",
3620 featureBranch: true,
3621 });
3622
3623 expect(result.branch).toEqual({ status: "created", name: scenario.expected });
3624 expect(result.commit.status).toBe("created");
3625 expect((yield* runGit(repoDir, ["branch", "--show-current"])).stdout.trim()).toBe(
3626 scenario.expected,
3627 );
3628 expect((yield* runGit(repoDir, ["status", "--porcelain"])).stdout.trim()).toBe("");
3629 for (const branch of ["main", ...scenario.existingBranches]) {
3630 expect((yield* runGit(repoDir, ["rev-parse", branch])).stdout.trim()).toBe(mainSha);
3631 }
3632 }),
3633 );
3634
3635 it.effect(
3636 "pushes and creates PR from a no-upstream branch when local commits are ahead of base",
3637 () =>
3638 Effect.gen(function* () {
3639 const repoDir = yield* makeTempDir("t3code-git-manager-");
3640 yield* initRepo(repoDir);
3641 yield* runGit(repoDir, ["checkout", "-b", "feature/no-upstream-pr"]);
3642 const remoteDir = yield* createBareRemote();
3643 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3644 NodeFS.writeFileSync(NodePath.join(repoDir, "feature.txt"), "feature\n");
3645
3646 const { manager, providerCalls } = yield* makeManager({
3647 providerScenario: {
3648 prListSequence: [
3649 [],
3650 [
3651 {
3652 number: 77,
3653 title: "Add no-upstream PR flow",
3654 url: "https://github.com/pingdotgg/codething-mvp/pull/77",
3655 baseRefName: "main",
3656 headRefName: "feature/no-upstream-pr",
3657 },
3658 ],
3659 ],
3660 },
3661 });
3662
3663 const result = yield* runStackedAction(manager, {
3664 cwd: repoDir,
3665 action: "commit_push_pr",
3666 });
3667
3668 expect(result.branch.status).toBe("skipped_not_requested");
3669 expect(result.commit.status).toBe("created");
3670 expect(result.push.status).toBe("pushed");
3671 expect(result.push.setUpstream).toBe(true);
3672 expect(result.pr.status).toBe("created");
3673 expect(
3674 yield* runGit(repoDir, ["rev-parse", "--abbrev-ref", "@{upstream}"]).pipe(
3675 Effect.map((result) => result.stdout.trim()),
3676 ),
3677 ).toBe("origin/feature/no-upstream-pr");
3678 expect(
3679 created(providerCalls).some(
3680 (call) => call.baseRefName === "main" && call.headSelector === "feature/no-upstream-pr",
3681 ),
3682 ).toBe(true);
3683 }),
3684 );
3685
3686 it.effect("pushes existing commits without committing dirty worktree changes", () =>
3687 Effect.gen(function* () {
3688 const repoDir = yield* makeTempDir("t3code-git-manager-");
3689 yield* initRepo(repoDir);
3690 yield* runGit(repoDir, ["checkout", "-b", "feature/push-dirty"]);
3691 const remoteDir = yield* createBareRemote();
3692 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3693 NodeFS.writeFileSync(NodePath.join(repoDir, "push-dirty.txt"), "push dirty\n");
3694 yield* runGit(repoDir, ["add", "push-dirty.txt"]);
3695 yield* runGit(repoDir, ["commit", "-m", "Push dirty branch"]);
3696 NodeFS.mkdirSync(NodePath.join(repoDir, ".vercel"));
3697 NodeFS.writeFileSync(NodePath.join(repoDir, ".vercel", "project.json"), "{}\n");
3698
3699 const { manager } = yield* makeManager();
3700 const result = yield* runStackedAction(manager, {
3701 cwd: repoDir,
3702 action: "push",
3703 });
3704
3705 expect(result.commit.status).toBe("skipped_not_requested");
3706 expect(result.push.status).toBe("pushed");
3707 expect(result.pr.status).toBe("skipped_not_requested");
3708 expect(
3709 yield* runGit(repoDir, ["status", "--porcelain"]).pipe(
3710 Effect.map((output) => output.stdout.trim()),
3711 ),
3712 ).toContain("?? .vercel/");
3713 expect(
3714 yield* runGit(remoteDir, [
3715 "--git-dir=.",
3716 "log",
3717 "-1",
3718 "--pretty=%s",
3719 "feature/push-dirty",
3720 ]).pipe(Effect.map((output) => output.stdout.trim())),
3721 ).toBe("Push dirty branch");
3722 }),
3723 );
3724
3725 it.effect("finishes a pushed commit when the final status read fails", () =>
3726 Effect.gen(function* () {
3727 const repoDir = yield* makeTempDir("t3code-git-manager-");
3728 yield* initRepo(repoDir);
3729 yield* runGit(repoDir, ["checkout", "-b", "feature/status-after-push"]);
3730 const remoteDir = yield* createBareRemote();
3731 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3732 NodeFS.writeFileSync(NodePath.join(repoDir, "change.txt"), "change\n");
3733 const gate = {
3734 matches: (args: ReadonlyArray<string>) => args[0] === "push",
3735 reached: yield* Deferred.make<void>(),
3736 release: yield* Deferred.make<void>(),
3737 };
3738 const events: GitActionProgressEvent[] = [];
3739 const { manager } = yield* makeManager({ gitSpawnGate: gate });
3740
3741 const action = yield* Effect.forkChild(
3742 runStackedAction(
3743 manager,
3744 { cwd: repoDir, action: "commit_push", commitMessage: "Status after push" },
3745 {
3746 progressReporter: {
3747 publish: (event) =>
3748 Effect.sync(() => {
3749 events.push(event);
3750 }),
3751 },
3752 },
3753 ),
3754 );
3755 yield* Deferred.await(gate.reached);
3756 NodeFS.writeFileSync(NodePath.join(repoDir, ".git", "index.lock"), "");
3757 yield* Deferred.succeed(gate.release, undefined);
3758 const result = yield* Fiber.join(action);
3759
3760 expect(result.push.status).toBe("pushed");
3761 expect(result.toast.cta).toEqual({ kind: "none" });
3762 expect(events.at(-1)?.kind).toBe("action_finished");
3763 expect(
3764 (yield* runGit(remoteDir, [
3765 "--git-dir=.",
3766 "log",
3767 "-1",
3768 "--pretty=%s",
3769 "feature/status-after-push",
3770 ])).stdout.trim(),
3771 ).toBe("Status after push");
3772 }),
3773 );
3774
3775 it.effect("hands the branch base to the host when a failed first push is retried", () =>
3776 Effect.gen(function* () {
3777 const repoDir = yield* makeTempDir("t3code-git-manager-");
3778 yield* initRepo(repoDir);
3779 const remoteDir = yield* createBareRemote();
3780 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3781 yield* runGit(repoDir, ["push", "-u", "origin", "HEAD:main"]);
3782 yield* runGit(repoDir, ["checkout", "-b", "feature/retried-push", "--track", "origin/main"]);
3783 NodeFS.writeFileSync(NodePath.join(repoDir, "retried.txt"), "retried\n");
3784 yield* runGit(repoDir, ["add", "retried.txt"]);
3785 yield* runGit(repoDir, ["commit", "-m", "Retried push"]);
3786 const rejectOnce = NodePath.join(remoteDir, "reject-once");
3787 NodeFS.writeFileSync(rejectOnce, "");
3788 NodeFS.writeFileSync(
3789 NodePath.join(remoteDir, "hooks", "pre-receive"),
3790 `#!/bin/sh\nif [ -f "${rejectOnce}" ]; then rm "${rejectOnce}"; exit 1; fi\n`,
3791 { mode: 0o755 },
3792 );
3793
3794 const recorded: Array<{ branch: string; baseBranch: string }> = [];
3795 const { service } = createFakeSourceControlProvider();
3796 const { manager } = yield* makeManager({
3797 sourceControlProvider: {
3798 ...service,
3799 recordBranchBase: ({ branch, baseBranch }) =>
3800 Effect.sync(() => {
3801 recorded.push({ branch, baseBranch });
3802 }),
3803 },
3804 });
3805 const failed = yield* runStackedAction(manager, { cwd: repoDir, action: "push" }).pipe(
3806 Effect.flip,
3807 );
3808 expect(failed).toBeDefined();
3809 const result = yield* runStackedAction(manager, { cwd: repoDir, action: "push" });
3810
3811 expect(result.push.status).toBe("pushed");
3812 expect(recorded).toEqual([{ branch: "feature/retried-push", baseBranch: "main" }]);
3813 }),
3814 );
3815
3816 it.effect("create_pr targets the remote default branch when it is not main", () =>
3817 Effect.gen(function* () {
3818 const repoDir = yield* makeTempDir("t3code-git-manager-");
3819 yield* initRepo(repoDir);
3820 const remoteDir = yield* createBareRemote();
3821 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3822 yield* runGit(repoDir, ["push", "origin", "HEAD:master"]);
3823 yield* runGit(repoDir, ["fetch", "origin"]);
3824 yield* runGit(repoDir, ["remote", "set-head", "origin", "master"]);
3825
3826 yield* runGit(repoDir, ["checkout", "-b", "feature/master-default"]);
3827 NodeFS.writeFileSync(NodePath.join(repoDir, "master-default.txt"), "master default\n");
3828 yield* runGit(repoDir, ["add", "master-default.txt"]);
3829 yield* runGit(repoDir, ["commit", "-m", "Master default"]);
3830
3831 const { manager, providerCalls } = yield* makeManager({
3832 providerScenario: {
3833 // Mirrors a provider that cannot report a default branch, as the Azure
3834 // DevOps CLI does when it cannot detect the repository.
3835 defaultBranch: "",
3836 prListSequence: [
3837 [],
3838 [
3839 {
3840 number: 505,
3841 title: "Master default",
3842 url: "https://github.com/pingdotgg/codething-mvp/pull/505",
3843 baseRefName: "master",
3844 headRefName: "feature/master-default",
3845 },
3846 ],
3847 ],
3848 },
3849 });
3850
3851 const result = yield* runStackedAction(manager, {
3852 cwd: repoDir,
3853 action: "create_pr",
3854 });
3855
3856 expect(result.pr.status).toBe("created");
3857 expect(
3858 created(providerCalls).some(
3859 (call) => call.baseRefName === "master" && call.headSelector === "feature/master-default",
3860 ),
3861 ).toBe(true);
3862 }),
3863 );
3864
3865 it.effect.each([
3866 { localBranch: "develop" },
3867 // Pushes to origin's develop under a name that differs from the base.
3868 { localBranch: "origin/develop" },
3869 ] as const)(
3870 "commit_push_pr refuses to commit or push on the default branch when origin/HEAD is missing ($localBranch)",
3871 ({ localBranch }) =>
3872 Effect.gen(function* () {
3873 const repoDir = yield* makeTempDir("t3code-git-manager-");
3874 yield* initRepo(repoDir);
3875 yield* runGit(repoDir, ["branch", "-m", "main", "develop"]);
3876 const remoteDir = yield* createBareRemote();
3877 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3878 yield* runGit(repoDir, ["push", "-u", "origin", "develop"]);
3879 if (localBranch !== "develop") yield* runGit(repoDir, ["checkout", "-b", localBranch]);
3880 const readRemoteDevelop = runGit(repoDir, [
3881 "ls-remote",
3882 "origin",
3883 "refs/heads/develop",
3884 ]).pipe(Effect.map((output) => output.stdout));
3885 const remoteBefore = yield* readRemoteDevelop;
3886 const localBefore = (yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout;
3887 NodeFS.writeFileSync(NodePath.join(repoDir, "change.txt"), "change\n");
3888
3889 const { manager } = yield* makeManager({
3890 providerScenario: { defaultBranch: "develop", prListSequence: [[], []] },
3891 });
3892
3893 const error = yield* runStackedAction(manager, {
3894 cwd: repoDir,
3895 action: "commit_push_pr",
3896 }).pipe(Effect.flip);
3897
3898 expect(yield* readRemoteDevelop).toBe(remoteBefore);
3899 expect((yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout).toBe(localBefore);
3900 expect(error.message).toContain("develop is the base branch");
3901 }),
3902 );
3903
3904 it.effect("commit_push_pr on the default branch returns its open PR into another base", () =>
3905 Effect.gen(function* () {
3906 const repoDir = yield* makeTempDir("t3code-git-manager-");
3907 yield* initRepo(repoDir);
3908 const remoteDir = yield* createBareRemote();
3909 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3910 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
3911 const releasePr = {
3912 number: 43,
3913 title: "Release",
3914 url: "https://github.com/pingdotgg/codething-mvp/pull/43",
3915 baseRefName: "release",
3916 headRefName: "main",
3917 };
3918
3919 const { manager } = yield* makeManager({
3920 providerScenario: { defaultBranch: "main", prListSequence: [[releasePr], [releasePr]] },
3921 });
3922 const result = yield* runStackedAction(manager, {
3923 cwd: repoDir,
3924 action: "commit_push_pr",
3925 });
3926
3927 expect(result.pr.status).toBe("opened_existing");
3928 expect(result.pr.number).toBe(43);
3929 }),
3930 );
3931
3932 it.effect(
3933 "commit_push_pr publishes a branch that tracks the default branch under its own name",
3934 () =>
3935 Effect.gen(function* () {
3936 const repoDir = yield* makeTempDir("t3code-git-manager-");
3937 yield* initRepo(repoDir);
3938 yield* runGit(repoDir, ["branch", "-m", "main", "develop"]);
3939 const remoteDir = yield* createBareRemote();
3940 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3941 yield* runGit(repoDir, ["push", "-u", "origin", "develop"]);
3942 yield* runGit(repoDir, ["checkout", "-b", "t3code/feature", "--track", "origin/develop"]);
3943 const readRemoteDevelop = runGit(repoDir, [
3944 "ls-remote",
3945 "origin",
3946 "refs/heads/develop",
3947 ]).pipe(Effect.map((output) => output.stdout));
3948 const remoteBefore = yield* readRemoteDevelop;
3949 NodeFS.writeFileSync(NodePath.join(repoDir, "change.txt"), "change\n");
3950
3951 const { manager, providerCalls } = yield* makeManager({
3952 providerScenario: {
3953 defaultBranch: "develop",
3954 prListSequence: [
3955 [],
3956 [
3957 {
3958 number: 506,
3959 title: "Feature",
3960 url: "https://github.com/pingdotgg/codething-mvp/pull/506",
3961 baseRefName: "develop",
3962 headRefName: "t3code/feature",
3963 },
3964 ],
3965 ],
3966 },
3967 });
3968
3969 const result = yield* runStackedAction(manager, {
3970 cwd: repoDir,
3971 action: "commit_push_pr",
3972 });
3973
3974 expect(result.pr.status).toBe("created");
3975 expect(yield* readRemoteDevelop).toBe(remoteBefore);
3976 expect(
3977 created(providerCalls).some(
3978 (call) => call.baseRefName === "develop" && call.headSelector === "t3code/feature",
3979 ),
3980 ).toBe(true);
3981 }),
3982 );
3983
3984 it.effect("create_pr reports a created PR when the lookup after creation fails", () =>
3985 Effect.gen(function* () {
3986 const repoDir = yield* makeTempDir("t3code-git-manager-");
3987 yield* initRepo(repoDir);
3988 yield* runGit(repoDir, ["checkout", "-b", "feature/lookup-after-create"]);
3989 const remoteDir = yield* createBareRemote();
3990 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
3991 NodeFS.writeFileSync(NodePath.join(repoDir, "lookup.txt"), "lookup\n");
3992 yield* runGit(repoDir, ["add", "lookup.txt"]);
3993 yield* runGit(repoDir, ["commit", "-m", "Lookup after create"]);
3994 yield* runGit(repoDir, ["push", "-u", "origin", "feature/lookup-after-create"]);
3995
3996 const { service: github } = createFakeSourceControlProvider();
3997 let created = false;
3998 const { manager } = yield* makeManager({
3999 sourceControlProvider: {
4000 ...github,
4001 createChangeRequest: (input) =>
4002 github.createChangeRequest(input).pipe(
4003 Effect.tap(() =>
4004 Effect.sync(() => {
4005 created = true;
4006 }),
4007 ),
4008 ),
4009 listChangeRequests: (input) =>
4010 created
4011 ? Effect.fail(
4012 new SourceControlProviderFailure({
4013 provider: github.kind,
4014 operation: "listChangeRequests",
4015 cwd: input.cwd,
4016 detail: "GitHub API rate limit exceeded.",
4017 }),
4018 )
4019 : github.listChangeRequests(input),
4020 },
4021 });
4022
4023 const result = yield* runStackedAction(manager, { cwd: repoDir, action: "create_pr" });
4024
4025 expect(created).toBe(true);
4026 expect(result.pr).toMatchObject({
4027 status: "created",
4028 headBranch: "feature/lookup-after-create",
4029 });
4030 expect(result.pr.url).toBeUndefined();
4031 }),
4032 );
4033
4034 it.effect("returns existing PR metadata for commit/push/pr action", () =>
4035 Effect.gen(function* () {
4036 const repoDir = yield* makeTempDir("t3code-git-manager-");
4037 yield* initRepo(repoDir);
4038 yield* runGit(repoDir, ["checkout", "-b", "feature/existing-pr"]);
4039 const remoteDir = yield* createBareRemote();
4040 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
4041 yield* runGit(repoDir, ["push", "-u", "origin", "feature/existing-pr"]);
4042
4043 const { manager, providerCalls } = yield* makeManager({
4044 providerScenario: {
4045 prListSequence: [
4046 [
4047 {
4048 number: 42,
4049 title: "Existing PR",
4050 url: "https://github.com/pingdotgg/codething-mvp/pull/42",
4051 baseRefName: "main",
4052 headRefName: "feature/existing-pr",
4053 },
4054 ],
4055 ],
4056 },
4057 });
4058 const result = yield* runStackedAction(manager, {
4059 cwd: repoDir,
4060 action: "commit_push_pr",
4061 });
4062
4063 expect(result.branch.status).toBe("skipped_not_requested");
4064 expect(result.pr.status).toBe("opened_existing");
4065 expect(result.pr.number).toBe(42);
4066 expect(result.toast).toEqual({
4067 title: "Opened PR #42",
4068 description: "Existing PR",
4069 cta: {
4070 kind: "open_pr",
4071 label: "View PR",
4072 url: "https://github.com/pingdotgg/codething-mvp/pull/42",
4073 },
4074 });
4075 expect(providerCalls.some((call) => call.operation === "getChangeRequest")).toBe(false);
4076 }),
4077 );
4078
4079 it.effect("matches a host's mounted heads without confusing forks sharing a branch", () =>
4080 Effect.sync(() => {
4081 // A host that serves repositories below a mount names them without it.
4082 const repositoryNameFromRemoteUrl = (url: string) =>
4083 url.replace(/^https:\/\/[^/]+\/forgejo\//u, "").replace(/\.git$/u, "");
4084 for (const owner of ["maria", "reviewer"]) {
4085 const pr = {
4086 number: 42,
4087 title: "Greeting",
4088 url: "https://forgejo.example/forgejo/maria/project/pulls/42",
4089 baseRefName: "main",
4090 headRefName: "greeting",
4091 state: "open" as const,
4092 isDraft: false,
4093 closedAt: null,
4094 mergedAt: null,
4095 updatedAt: Option.none(),
4096 isCrossRepository: owner !== "maria",
4097 headRepositoryNameWithOwner: `${owner}/project`,
4098 headRepositoryOwnerLogin: owner,
4099 };
4100 const repository = GitManager.parseRepositoryNameWithOwnerFromRemoteUrl(
4101 `https://forgejo.example/forgejo/${owner}/project.git`,
4102 { repositoryNameFromRemoteUrl },
4103 );
4104 expect(repository).toBe(`${owner}/project`);
4105 const context = {
4106 headBranch: "greeting",
4107 headRepositoryNameWithOwner: repository,
4108 headRepositoryOwnerLogin: repository?.split("/")[0] ?? null,
4109 isCrossRepository: owner !== "maria",
4110 };
4111 expect(GitManager.matchesBranchHeadContext(pr, context)).toBe(true);
4112 expect(
4113 GitManager.matchesBranchHeadContext(pr, {
4114 ...context,
4115 headRepositoryNameWithOwner: "other/project",
4116 headRepositoryOwnerLogin: "other",
4117 }),
4118 ).toBe(false);
4119 }
4120 expect(
4121 GitManager.parseRepositoryNameWithOwnerFromRemoteUrl(
4122 "https://gitlab.example/group/maria/project.git",
4123 {},
4124 ),
4125 ).toBe("group/maria/project");
4126 }),
4127 );
4128
4129 it.effect("rejects same-repo PR metadata when matching a cross-repo head context", () =>
4130 Effect.sync(() => {
4131 const headContext = {
4132 headBranch: "statemachine",
4133 headRepositoryNameWithOwner: "pingdotgg/codething-mvp",
4134 headRepositoryOwnerLogin: "pingdotgg",
4135 isCrossRepository: true,
4136 };
4137
4138 expect(
4139 GitManager.matchesBranchHeadContext(
4140 {
4141 number: 41,
4142 title: "Same-repo PR",
4143 url: "https://github.com/pingdotgg/codething-mvp/pull/41",
4144 baseRefName: "main",
4145 headRefName: "statemachine",
4146 state: "open",
4147 updatedAt: Option.none(),
4148 isCrossRepository: false,
4149 headRepositoryNameWithOwner: "pingdotgg/codething-mvp",
4150 headRepositoryOwnerLogin: "pingdotgg",
4151 },
4152 headContext,
4153 ),
4154 ).toBe(false);
4155
4156 expect(
4157 GitManager.matchesBranchHeadContext(
4158 {
4159 number: 142,
4160 title: "Fork PR",
4161 url: "https://github.com/pingdotgg/codething-mvp/pull/142",
4162 baseRefName: "main",
4163 headRefName: "statemachine",
4164 state: "open",
4165 updatedAt: Option.none(),
4166 isCrossRepository: true,
4167 headRepositoryNameWithOwner: "pingdotgg/codething-mvp",
4168 headRepositoryOwnerLogin: "pingdotgg",
4169 },
4170 headContext,
4171 ),
4172 ).toBe(true);
4173 }),
4174 );
4175
4176 it.effect("accepts fork PR metadata when origin is the fork checkout remote", () =>
4177 Effect.sync(() => {
4178 const headContext = {
4179 headBranch: "t3code/git-audit-stability",
4180 headRepositoryNameWithOwner: "justsomelegs/t3code",
4181 headRepositoryOwnerLogin: "justsomelegs",
4182 isCrossRepository: false,
4183 };
4184
4185 expect(
4186 GitManager.matchesBranchHeadContext(
4187 {
4188 number: 2284,
4189 title: "Improve branch mismatch warnings",
4190 url: "https://github.com/pingdotgg/t3code/pull/2284",
4191 baseRefName: "main",
4192 headRefName: "t3code/git-audit-stability",
4193 state: "open",
4194 updatedAt: Option.none(),
4195 isCrossRepository: true,
4196 headRepositoryNameWithOwner: "justsomelegs/t3code",
4197 headRepositoryOwnerLogin: "justsomelegs",
4198 },
4199 headContext,
4200 ),
4201 ).toBe(true);
4202 }),
4203 );
4204
4205 it.effect("create_pr sends bounded checks to the model and omits rolled-back runs", () =>
4206 Effect.gen(function* () {
4207 const repoDir = yield* makeTempDir("t3code-git-manager-");
4208 yield* initRepo(repoDir);
4209 yield* runGit(repoDir, ["checkout", "-b", "feature/thread-context"]);
4210 NodeFS.writeFileSync(NodePath.join(repoDir, "thread-context.txt"), "context\n");
4211 yield* runGit(repoDir, ["add", "thread-context.txt"]);
4212 yield* runGit(repoDir, ["commit", "-m", "Thread context"]);
4213 const remoteDir = yield* createBareRemote();
4214 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
4215 const threadId = ThreadId.make("thread:pr-thread-context");
4216 const providerInstanceId = ProviderInstanceId.make("codex");
4217 const createdAt = DateTime.makeUnsafe("2026-09-27T00:00:00.000Z");
4218 const run = (ordinal: number, status: "completed" | "rolled_back") => ({
4219 id: RunId.make(`run:pr-thread-context:${ordinal}`),
4220 threadId,
4221 ordinal,
4222 providerInstanceId,
4223 modelSelection: { instanceId: providerInstanceId, model: "gpt-5" },
4224 providerThreadId: null,
4225 userMessageId: MessageId.make(`message:pr-thread-context:${ordinal}`),
4226 rootNodeId: null,
4227 activeAttemptId: null,
4228 status,
4229 requestedAt: createdAt,
4230 startedAt: createdAt,
4231 completedAt: createdAt,
4232 checkpointId: null,
4233 contextHandoffId: null,
4234 });
4235 const itemBase = (ordinal: number, runId: RunId) => ({
4236 id: TurnItemId.make(`item:pr-thread-context:${ordinal}`),
4237 threadId,
4238 runId,
4239 nodeId: null,
4240 providerThreadId: null,
4241 providerTurnId: null,
4242 nativeItemRef: null,
4243 parentItemId: null,
4244 ordinal,
4245 status: "completed" as const,
4246 title: null,
4247 startedAt: createdAt,
4248 completedAt: createdAt,
4249 updatedAt: createdAt,
4250 });
4251 let generatedThreadContext: string | undefined;
4252 let generatedPrompt = "";
4253 const writer = fromRunner("test", (request) => {
4254 generatedPrompt = request.prompt;
4255 return decodeJsonReply(request, "test", '{"title":"Thread context","body":"Body"}');
4256 });
4257
4258 const { manager } = yield* makeManager({
4259 textGeneration: {
4260 generatePrContent: (input) => {
4261 generatedThreadContext = input.threadContext;
4262 return writer.generatePrContent(input);
4263 },
4264 },
4265 seed: Effect.gen(function* () {
4266 const store = yield* ProjectionStore.ProjectionStoreV2;
4267 const completedRun = run(1, "completed");
4268 const abandonedRun = run(2, "rolled_back");
4269 yield* store.apply({
4270 id: EventId.make("event:pr-thread-context:thread"),
4271 type: "thread.created",
4272 threadId,
4273 providerInstanceId,
4274 occurredAt: createdAt,
4275 payload: {
4276 createdBy: "user",
4277 creationSource: "web",
4278 id: threadId,
4279 projectId: ProjectId.make("project:pr-thread-context"),
4280 title: "PR thread context",
4281 providerInstanceId,
4282 modelSelection: { instanceId: providerInstanceId, model: "gpt-5" },
4283 runtimeMode: "full-access",
4284 interactionMode: "default",
4285 branch: null,
4286 worktreePath: repoDir,
4287 activeProviderThreadId: null,
4288 lineage: {
4289 parentThreadId: null,
4290 relationshipToParent: null,
4291 rootThreadId: threadId,
4292 },
4293 forkedFrom: null,
4294 createdAt,
4295 updatedAt: createdAt,
4296 archivedAt: null,
4297 settledOverride: null,
4298 settledAt: null,
4299 lastVisitedAt: null,
4300 deletedAt: null,
4301 },
4302 });
4303 for (const payload of [completedRun, abandonedRun]) {
4304 yield* store.apply({
4305 id: EventId.make(`event:pr-thread-context:run:${payload.ordinal}`),
4306 type: "run.updated",
4307 threadId,
4308 runId: payload.id,
4309 occurredAt: createdAt,
4310 payload,
4311 });
4312 }
4313 const items = [
4314 {
4315 ...itemBase(1, completedRun.id),
4316 type: "user_message" as const,
4317 messageId: completedRun.userMessageId,
4318 createdBy: "user" as const,
4319 creationSource: "web" as const,
4320 inputIntent: "turn_start" as const,
4321 text: "Make the PR writer see the thread",
4322 attachments: [],
4323 },
4324 {
4325 ...itemBase(3, completedRun.id),
4326 type: "command_execution" as const,
4327 input: "vp test run",
4328 output: `${"collecting tests\n".repeat(4_000)}Tests 12 passed`,
4329 exitCode: 0,
4330 },
4331 {
4332 ...itemBase(4, completedRun.id),
4333 type: "command_execution" as const,
4334 input: "vp lint",
4335 output: "2 lint errors",
4336 exitCode: 1,
4337 },
4338 {
4339 ...itemBase(5, abandonedRun.id),
4340 type: "command_execution" as const,
4341 input: "vp run abandoned",
4342 output: "abandoned output",
4343 exitCode: 0,
4344 },
4345 ];
4346 for (const payload of items) {
4347 yield* store.apply({
4348 id: EventId.make(`event:pr-thread-context:${payload.id}`),
4349 type: "turn-item.updated",
4350 threadId,
4351 runId: payload.runId,
4352 occurredAt: createdAt,
4353 payload,
4354 });
4355 }
4356 }),
4357 });
4358
4359 yield* manager.runStackedAction({
4360 actionId: "test-action-id",
4361 cwd: repoDir,
4362 action: "create_pr",
4363 threadId,
4364 });
4365
4366 expect(generatedPrompt).toContain("Command: vp test run\nExit code: 0");
4367 expect(generatedPrompt).toContain("Tests 12 passed");
4368 expect(generatedPrompt).toContain("Make the PR writer see the thread");
4369 expect(generatedPrompt).toContain("Command: vp lint\nExit code: 1");
4370 expect(generatedPrompt).toContain("2 lint errors");
4371 expect(generatedPrompt).not.toContain("vp run abandoned");
4372 expect(generatedPrompt).not.toContain("abandoned output");
4373 expect(Buffer.byteLength(generatedThreadContext ?? "")).toBeLessThanOrEqual(16_000);
4374 }),
4375 );
4376
4377 it.effect.each(["commit", "short-commit", "tag", "revision"] as const)(
4378 "creates a PR against the default branch with a legacy %s base setting",
4379 (kind) =>
4380 Effect.gen(function* () {
4381 const repoDir = yield* makeTempDir("t3code-git-manager-");
4382 yield* initRepo(repoDir);
4383 yield* runGit(repoDir, ["branch", "-m", "main", "trunk"]);
4384 const remoteDir = yield* createBareRemote();
4385 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
4386 yield* runGit(repoDir, ["push", "-u", "origin", "trunk"]);
4387 yield* runGit(repoDir, ["checkout", "-b", "feature/legacy-base"]);
4388 NodeFS.writeFileSync(NodePath.join(repoDir, "feature.txt"), "feature\n");
4389 yield* runGit(repoDir, ["add", "feature.txt"]);
4390 yield* runGit(repoDir, ["commit", "-m", "Feature commit"]);
4391 const commit = (yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout.trim();
4392 yield* runGit(repoDir, ["tag", "v1"]);
4393 const baseRef =
4394 kind === "commit"
4395 ? commit
4396 : kind === "short-commit"
4397 ? commit.slice(0, 12)
4398 : kind === "tag"
4399 ? "v1"
4400 : "HEAD~0";
4401 yield* runGit(repoDir, ["config", "branch.feature/legacy-base.gh-merge-base", baseRef]);
4402 yield* runGit(repoDir, ["push", "-u", "origin", "feature/legacy-base"]);
4403 let generatedBase = "";
4404 let generatedSummary = "";
4405 const { manager, providerCalls } = yield* makeManager({
4406 providerScenario: { defaultBranch: "trunk", prListSequence: [[], []] },
4407 textGeneration: {
4408 generatePrContent: (input) => {
4409 generatedBase = input.baseBranch;
4410 generatedSummary = input.commitSummary;
4411 return Effect.succeed({ title: "Feature PR", body: "Feature body" });
4412 },
4413 },
4414 });
4415
4416 const result = yield* runStackedAction(manager, { cwd: repoDir, action: "create_pr" });
4417
4418 expect(result.pr.status).toBe("created");
4419 expect(generatedBase).toBe("trunk");
4420 expect(generatedSummary).toContain("Feature commit");
4421 expect(
4422 created(providerCalls).some(
4423 (call) => call.baseRefName === "trunk" && call.headSelector === "feature/legacy-base",
4424 ),
4425 ).toBe(true);
4426 }),
4427 );
4428
4429 it.effect("createPullRequest pushes the branch before opening its PR", () =>
4430 Effect.gen(function* () {
4431 const repoDir = yield* makeTempDir("t3code-git-manager-");
4432 yield* initRepo(repoDir);
4433 const remoteDir = yield* createBareRemote();
4434 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
4435 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
4436 yield* runGit(repoDir, ["checkout", "-b", "feature/unpushed"]);
4437 NodeFS.writeFileSync(NodePath.join(repoDir, "first.txt"), "first\n");
4438 yield* runGit(repoDir, ["add", "first.txt"]);
4439 yield* runGit(repoDir, ["commit", "-m", "First commit"]);
4440 const remoteHead = (branch: string) =>
4441 runGit(repoDir, ["ls-remote", "origin", `refs/heads/${branch}`]).pipe(
4442 Effect.map((result) => result.stdout.split("\t")[0]),
4443 );
4444 const localHead = () =>
4445 runGit(repoDir, ["rev-parse", "HEAD"]).pipe(Effect.map((result) => result.stdout.trim()));
4446
4447 // A branch without an upstream is published first.
4448 const unpublished = yield* makeManager({ providerScenario: { prListSequence: [[], []] } });
4449 yield* unpublished.manager.createPullRequest({
4450 cwd: repoDir,
4451 projectId: ProjectId.make("project-1"),
4452 title: "Feature",
4453 body: "Body",
4454 });
4455 expect(yield* remoteHead("feature/unpushed")).toBe(yield* localHead());
4456 expect(created(unpublished.providerCalls)).toMatchObject([
4457 { headSelector: "feature/unpushed" },
4458 ]);
4459
4460 // Commits made after publishing are pushed too.
4461 NodeFS.writeFileSync(NodePath.join(repoDir, "late.txt"), "late\n");
4462 yield* runGit(repoDir, ["add", "late.txt"]);
4463 yield* runGit(repoDir, ["commit", "-m", "Late commit"]);
4464 const ahead = yield* makeManager({ providerScenario: { prListSequence: [[], []] } });
4465 yield* ahead.manager.createPullRequest({
4466 cwd: repoDir,
4467 projectId: ProjectId.make("project-1"),
4468 title: "Feature",
4469 body: "Body",
4470 });
4471 expect(yield* remoteHead("feature/unpushed")).toBe(yield* localHead());
4472 expect(created(ahead.providerCalls)).toHaveLength(1);
4473
4474 // A rejected push fails with git's reason and opens nothing; it never forces.
4475 const otherDir = yield* makeTempDir("t3code-git-manager-other-");
4476 yield* runGit(otherDir, ["clone", "--branch", "feature/unpushed", remoteDir, "."]);
4477 yield* runGit(otherDir, ["config", "user.email", "other@example.com"]);
4478 yield* runGit(otherDir, ["config", "user.name", "Other"]);
4479 NodeFS.writeFileSync(NodePath.join(otherDir, "theirs.txt"), "theirs\n");
4480 yield* runGit(otherDir, ["add", "theirs.txt"]);
4481 yield* runGit(otherDir, ["commit", "-m", "Their commit"]);
4482 yield* runGit(otherDir, ["push"]);
4483 const theirHead = yield* remoteHead("feature/unpushed");
4484 NodeFS.writeFileSync(NodePath.join(repoDir, "mine.txt"), "mine\n");
4485 yield* runGit(repoDir, ["add", "mine.txt"]);
4486 yield* runGit(repoDir, ["commit", "-m", "My commit"]);
4487 const rejected = yield* makeManager({ providerScenario: { prListSequence: [[], []] } });
4488 const error = yield* Effect.flip(
4489 rejected.manager.createPullRequest({
4490 cwd: repoDir,
4491 projectId: ProjectId.make("project-1"),
4492 title: "Feature",
4493 body: "Body",
4494 }),
4495 );
4496 expect(error.message).toContain("Could not push feature/unpushed");
4497 expect(error.message).toContain("Pull or rebase, then push again");
4498 expect(yield* remoteHead("feature/unpushed")).toBe(theirHead);
4499 expect(created(rejected.providerCalls)).toEqual([]);
4500 yield* runGit(repoDir, ["fetch", "origin"]);
4501 yield* runGit(repoDir, ["reset", "--hard", "origin/feature/unpushed"]);
4502
4503 // A publish whose upstream cannot be recorded says so instead of claiming nothing was pushed.
4504 yield* runGit(repoDir, ["checkout", "-b", "feature/locked"]);
4505 const lockPath = NodePath.join(repoDir, ".git", "config.lock");
4506 NodeFS.writeFileSync(lockPath, "");
4507 const locked = yield* makeManager({ providerScenario: { prListSequence: [[], []] } });
4508 // The upstream write retries on the real clock before giving up.
4509 const lockedError = yield* Effect.flip(
4510 TestClock.withLive(
4511 locked.manager.createPullRequest({
4512 cwd: repoDir,
4513 projectId: ProjectId.make("project-1"),
4514 title: "Feature",
4515 body: "Body",
4516 }),
4517 ),
4518 );
4519 NodeFS.rmSync(lockPath);
4520 expect(lockedError.message).toContain("could not record it as the branch's upstream");
4521 expect(yield* remoteHead("feature/locked")).toBe(yield* localHead());
4522 expect(created(locked.providerCalls)).toEqual([]);
4523 yield* runGit(repoDir, ["checkout", "feature/unpushed"]);
4524
4525 const open = {
4526 number: 7,
4527 title: "Feature",
4528 url: "https://github.com/pingdotgg/codething-mvp/pull/7",
4529 baseRefName: "main",
4530 headRefName: "feature/unpushed",
4531 };
4532 // Pushing into an open PR returns it, and status no longer reports the pushed commit.
4533 NodeFS.writeFileSync(NodePath.join(repoDir, "into-open.txt"), "into open\n");
4534 yield* runGit(repoDir, ["add", "into-open.txt"]);
4535 yield* runGit(repoDir, ["commit", "-m", "Into open PR"]);
4536 const existing = yield* makeManager({
4537 providerScenario: { prListSequence: [[open], [open], [open], [open]] },
4538 });
4539 expect((yield* existing.manager.status({ cwd: repoDir })).aheadCount).toBe(1);
4540 const found = yield* existing.manager.createPullRequest({
4541 cwd: repoDir,
4542 projectId: ProjectId.make("project-1"),
4543 title: "Feature",
4544 body: "Body",
4545 });
4546 expect(found).toMatchObject({ status: "opened_existing", number: 7 });
4547 expect((yield* existing.manager.status({ cwd: repoDir })).aheadCount).toBe(0);
4548
4549 // A retry after a failed draft finds the open PR and still drafts it.
4550 const actions: Array<PullRequestActionInput> = [];
4551 const retried = yield* makeManager({
4552 providerScenario: { prListSequence: [[open]] },
4553 pullRequests: {
4554 summary: () => Effect.succeed({ isDraft: false } as never),
4555 runAction: (action) => Effect.sync(() => void actions.push(action)),
4556 },
4557 });
4558 yield* retried.manager.createPullRequest({
4559 cwd: repoDir,
4560 projectId: ProjectId.make("project-1"),
4561 title: "Feature",
4562 body: "Body",
4563 draft: true,
4564 });
4565 expect(actions).toMatchObject([
4566 { repository: "pingdotgg/codething-mvp", number: 7, action: "draft" },
4567 ]);
4568
4569 // A draft of a PR the host does not list yet fails, so a retry drafts it.
4570 const unlisted = yield* makeManager({
4571 providerScenario: { prListSequence: [[], []], createsDraftChangeRequests: false },
4572 });
4573 const notListed = yield* Effect.flip(
4574 unlisted.manager.createPullRequest({
4575 cwd: repoDir,
4576 projectId: ProjectId.make("project-1"),
4577 title: "Feature",
4578 body: "Body",
4579 draft: true,
4580 }),
4581 );
4582 expect(notListed.message).toContain("does not list it yet");
4583 expect(created(unlisted.providerCalls)).toHaveLength(1);
4584
4585 // A new PR asked for as a draft is opened as one, never ready first.
4586 const newActions: Array<PullRequestActionInput> = [];
4587 const fresh = yield* makeManager({
4588 providerScenario: { prListSequence: [[], [open]] },
4589 pullRequests: {
4590 summary: () => Effect.succeed({ isDraft: false } as never),
4591 runAction: (action) => Effect.sync(() => void newActions.push(action)),
4592 },
4593 });
4594 yield* fresh.manager.createPullRequest({
4595 cwd: repoDir,
4596 projectId: ProjectId.make("project-1"),
4597 title: "Feature",
4598 body: "Body",
4599 draft: true,
4600 });
4601 expect(
4602 fresh.providerCalls.flatMap((call) =>
4603 call.operation === "createChangeRequest" ? [call.draft] : [],
4604 ),
4605 ).toEqual([true]);
4606 expect(newActions).toEqual([]);
4607 }),
4608 );
4609
4610 it.effect("createPullRequest pushes to the push remote and never to the base branch", () =>
4611 Effect.gen(function* () {
4612 const repoDir = yield* makeTempDir("t3code-git-manager-");
4613 yield* initRepo(repoDir);
4614 const originDir = yield* createBareRemote();
4615 const forkDir = yield* createBareRemote();
4616 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
4617 yield* runGit(repoDir, ["push", "-u", "origin", "main"]);
4618 yield* runGit(repoDir, ["remote", "add", "fork", forkDir]);
4619 const readOrigin = (branch: string) =>
4620 runGit(repoDir, ["ls-remote", "origin", `refs/heads/${branch}`]).pipe(
4621 Effect.map((result) => result.stdout),
4622 );
4623 const commit = (file: string) =>
4624 Effect.gen(function* () {
4625 NodeFS.writeFileSync(NodePath.join(repoDir, file), `${file}\n`);
4626 yield* runGit(repoDir, ["add", file]);
4627 yield* runGit(repoDir, ["commit", "-m", file]);
4628 });
4629 const createPr = (manager: GitManager.GitManager["Service"]) =>
4630 manager.createPullRequest({
4631 cwd: repoDir,
4632 projectId: ProjectId.make("project-1"),
4633 title: "Feature",
4634 body: "Body",
4635 });
4636
4637 // Commits on the base branch are never pushed to it.
4638 yield* commit("on-main.txt");
4639 const originMain = yield* readOrigin("main");
4640 const onBase = yield* makeManager({ providerScenario: { prListSequence: [[]] } });
4641 const error = yield* Effect.flip(createPr(onBase.manager));
4642 expect(error.message).toContain("main is the base branch");
4643 expect(yield* readOrigin("main")).toBe(originMain);
4644 expect(created(onBase.providerCalls)).toEqual([]);
4645 yield* runGit(repoDir, ["reset", "--hard", "origin/main"]);
4646
4647 // A push to a separate push remote leaves the upstream behind, and still opens the PR.
4648 yield* runGit(repoDir, ["checkout", "-b", "topic"]);
4649 yield* commit("topic.txt");
4650 yield* runGit(repoDir, ["push", "-u", "origin", "topic"]);
4651 yield* commit("late.txt");
4652 yield* configureVisibleRemoteUrlWithLocalRewrite(
4653 repoDir,
4654 "origin",
4655 "git@github.com:pingdotgg/codething-mvp.git",
4656 originDir,
4657 );
4658 yield* configureVisibleRemoteUrlWithLocalRewrite(
4659 repoDir,
4660 "fork",
4661 "git@github.com:octocat/codething-mvp.git",
4662 forkDir,
4663 );
4664 yield* runGit(repoDir, ["config", "remote.pushDefault", "fork"]);
4665 const viaFork = yield* makeManager();
4666 const result = yield* createPr(viaFork.manager);
4667 expect(result.status).toBe("created");
4668 expect(
4669 yield* runGit(forkDir, ["--git-dir=.", "log", "-1", "--pretty=%s", "topic"]),
4670 ).toMatchObject({ stdout: "late.txt\n" });
4671 expect(created(viaFork.providerCalls)).toEqual([
4672 { baseRefName: "main", headSelector: "octocat:topic" },
4673 ]);
4674 }),
4675 );
4676
4677 it.effect("generates PR content from the created worktree's selected remote base", () =>
4678 Effect.gen(function* () {
4679 const repoDir = yield* makeTempDir("t3code-git-manager-");
4680 yield* initRepo(repoDir);
4681 const originDir = yield* createBareRemote();
4682 const upstreamDir = yield* createBareRemote();
4683 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
4684 yield* runGit(repoDir, ["remote", "add", "upstream", upstreamDir]);
4685 yield* runGit(repoDir, ["checkout", "-b", "fork-release"]);
4686 NodeFS.writeFileSync(NodePath.join(repoDir, "fork.txt"), "fork-only work\n");
4687 NodeFS.mkdirSync(NodePath.join(repoDir, ".github"));
4688 NodeFS.writeFileSync(
4689 NodePath.join(repoDir, ".github/pull_request_template.md"),
4690 "Fork template",
4691 );
4692 yield* runGit(repoDir, ["add", "."]);
4693 yield* runGit(repoDir, ["commit", "-m", "Fork release commit"]);
4694 yield* runGit(repoDir, ["push", "origin", "HEAD:refs/heads/release"]);
4695 yield* runGit(repoDir, ["checkout", "-b", "stable", "main"]);
4696 NodeFS.writeFileSync(NodePath.join(repoDir, "upstream.txt"), "upstream-only work\n");
4697 NodeFS.mkdirSync(NodePath.join(repoDir, ".github"));
4698 NodeFS.writeFileSync(
4699 NodePath.join(repoDir, ".github/pull_request_template.md"),
4700 "Upstream template",
4701 );
4702 yield* runGit(repoDir, ["add", "."]);
4703 yield* runGit(repoDir, ["commit", "-m", "Upstream release commit"]);
4704 yield* runGit(repoDir, ["push", "-u", "upstream", "stable:release"]);
4705 yield* runGit(repoDir, ["branch", "upstream/release", "fork-release"]);
4706
4707 const driver = yield* GitVcsDriver.GitVcsDriver;
4708 const fetched = yield* driver.fetchWorktreeBaseCommit({ cwd: repoDir, refName: "stable" });
4709 expect(fetched).not.toBeNull();
4710 const worktreePath = NodePath.join(yield* makeTempDir("t3code-git-worktrees-"), "feature");
4711 yield* driver.createWorktree({
4712 cwd: repoDir,
4713 path: worktreePath,
4714 refName: fetched!.commitSha,
4715 newRefName: "feature/from-upstream",
4716 baseRefName: `refs/remotes/${fetched!.remoteRefName}`,
4717 });
4718 NodeFS.writeFileSync(NodePath.join(worktreePath, "feature.txt"), "feature work\n");
4719 yield* runGit(worktreePath, ["add", "feature.txt"]);
4720 yield* runGit(worktreePath, ["commit", "-m", "Feature commit"]);
4721 yield* runGit(worktreePath, ["push", "-u", "origin", "feature/from-upstream"]);
4722
4723 const generatedInputs: TextGeneration.PrContentGenerationInput[] = [];
4724 const { manager, providerCalls } = yield* makeManager({
4725 providerScenario: { prListSequence: [[], []] },
4726 textGeneration: {
4727 generatePrContent: (input) => {
4728 generatedInputs.push(input);
4729 return Effect.succeed({ title: "Feature PR", body: "Feature body" });
4730 },
4731 },
4732 });
4733 const result = yield* runStackedAction(manager, { cwd: worktreePath, action: "create_pr" });
4734
4735 expect(result.pr.status).toBe("created");
4736 expect(generatedInputs).toHaveLength(1);
4737 const generated = generatedInputs[0]!;
4738 expect.soft(generated.commitSummary).toContain("Feature commit");
4739 expect.soft(generated.commitSummary).not.toContain("Upstream release commit");
4740 expect.soft(generated.commitSummary).not.toContain("Fork release commit");
4741 expect.soft(generated.diffSummary).toContain("feature.txt");
4742 expect.soft(generated.diffSummary).not.toContain("upstream.txt");
4743 expect.soft(generated.diffSummary).not.toContain("fork.txt");
4744 expect.soft(generated.diffPatch).toContain("+feature work");
4745 expect.soft(generated.diffPatch).not.toContain("upstream-only work");
4746 expect.soft(generated.diffPatch).not.toContain("fork-only work");
4747 expect.soft(generated.changeRequestTemplate).toBe("Upstream template");
4748 expect(
4749 created(providerCalls).some(
4750 (call) => call.baseRefName === "release" && call.headSelector === "feature/from-upstream",
4751 ),
4752 ).toBe(true);
4753 }),
4754 );
4755
4756 it.effect(
4757 "preserves a local worktree PR base that shadows a remote ref, including legacy bases",
4758 () =>
4759 Effect.gen(function* () {
4760 const repoDir = yield* makeTempDir("t3code-git-manager-");
4761 yield* initRepo(repoDir);
4762 const originDir = yield* createBareRemote();
4763 const upstreamDir = yield* createBareRemote();
4764 yield* runGit(repoDir, ["remote", "add", "origin", originDir]);
4765 yield* runGit(repoDir, ["remote", "add", "upstream", upstreamDir]);
4766 yield* runGit(repoDir, ["checkout", "-b", "release"]);
4767 NodeFS.mkdirSync(NodePath.join(repoDir, ".github"));
4768 NodeFS.writeFileSync(NodePath.join(repoDir, "remote.txt"), "remote-only work\n");
4769 NodeFS.writeFileSync(
4770 NodePath.join(repoDir, ".github/pull_request_template.md"),
4771 "Remote release template",
4772 );
4773 yield* runGit(repoDir, ["add", "."]);
4774 yield* runGit(repoDir, ["commit", "-m", "Remote release commit"]);
4775 yield* runGit(repoDir, ["push", "upstream", "release"]);
4776
4777 yield* runGit(repoDir, ["checkout", "-b", "upstream/release", "main"]);
4778 NodeFS.mkdirSync(NodePath.join(repoDir, ".github"));
4779 NodeFS.writeFileSync(NodePath.join(repoDir, "local.txt"), "local-base work\n");
4780 NodeFS.writeFileSync(
4781 NodePath.join(repoDir, ".github/pull_request_template.md"),
4782 "Local branch template",
4783 );
4784 yield* runGit(repoDir, ["add", "."]);
4785 yield* runGit(repoDir, ["commit", "-m", "Local base commit"]);
4786 yield* runGit(repoDir, ["push", "upstream", "refs/heads/upstream/release"]);
4787 yield* runGit(repoDir, ["push", "origin", "refs/heads/upstream/release"]);
4788
4789 const driver = yield* GitVcsDriver.GitVcsDriver;
4790 const worktreePath = NodePath.join(yield* makeTempDir("t3code-git-worktrees-"), "feature");
4791 yield* driver.createWorktree({
4792 cwd: repoDir,
4793 path: worktreePath,
4794 refName: "refs/heads/upstream/release",
4795 newRefName: "feature/from-local",
4796 baseRefName: "refs/heads/upstream/release",
4797 });
4798 NodeFS.writeFileSync(NodePath.join(worktreePath, "feature.txt"), "feature work\n");
4799 yield* runGit(worktreePath, ["add", "feature.txt"]);
4800 yield* runGit(worktreePath, ["commit", "-m", "Feature commit"]);
4801 yield* runGit(worktreePath, ["push", "-u", "origin", "feature/from-local"]);
4802
4803 const generatedInputs: TextGeneration.PrContentGenerationInput[] = [];
4804 const { manager, providerCalls } = yield* makeManager({
4805 providerScenario: { prListSequence: [[], [], [], []] },
4806 textGeneration: {
4807 generatePrContent: (input) => {
4808 generatedInputs.push(input);
4809 return Effect.succeed({ title: "Feature PR", body: "Feature body" });
4810 },
4811 },
4812 });
4813 const result = yield* runStackedAction(manager, { cwd: worktreePath, action: "create_pr" });
4814 expect(result.pr.status).toBe("created");
4815
4816 // A branch created outside T3 has only gh's legacy short base setting.
4817 yield* runGit(worktreePath, ["checkout", "-b", "feature/legacy-local-base"]);
4818 yield* runGit(worktreePath, [
4819 "config",
4820 "branch.feature/legacy-local-base.gh-merge-base",
4821 "upstream/release",
4822 ]);
4823 yield* runGit(worktreePath, ["push", "-u", "origin", "feature/legacy-local-base"]);
4824 const legacyResult = yield* runStackedAction(manager, {
4825 cwd: worktreePath,
4826 action: "create_pr",
4827 });
4828 expect(legacyResult.pr.status).toBe("created");
4829 expect(generatedInputs).toHaveLength(2);
4830 for (const generated of generatedInputs) {
4831 expect.soft(generated.baseBranch).toBe("upstream/release");
4832 expect.soft(generated.commitSummary.trim()).toMatch(/^[a-f0-9]+ Feature commit$/);
4833 expect.soft(generated.diffSummary).toContain("feature.txt");
4834 expect.soft(generated.diffSummary).toContain("1 file changed, 1 insertion(+)");
4835 expect.soft(generated.diffPatch).toContain("+feature work");
4836 expect.soft(generated.diffPatch).not.toContain("local-base work");
4837 expect.soft(generated.diffPatch).not.toContain("remote-only work");
4838 expect.soft(generated.diffPatch).not.toContain("pull_request_template.md");
4839 expect.soft(generated.changeRequestTemplate).toBe("Local branch template");
4840 }
4841 expect.soft(created(providerCalls)).toEqual([
4842 { baseRefName: "upstream/release", headSelector: "feature/from-local" },
4843 { baseRefName: "upstream/release", headSelector: "feature/legacy-local-base" },
4844 ]);
4845 }),
4846 );
4847
4848 it.effect.each(["main", "release/1.2"])(
4849 "generates PR content from branch changes when the remote base advances (%s)",
4850 (baseBranch) =>
4851 Effect.gen(function* () {
4852 const repoDir = yield* makeTempDir("t3code-git-manager-");
4853 yield* initRepo(repoDir);
4854 yield* runGit(repoDir, ["branch", "-m", baseBranch]);
4855 const remoteDir = yield* createBareRemote();
4856 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
4857 yield* runGit(repoDir, ["push", "-u", "origin", baseBranch]);
4858 yield* runGit(remoteDir, [
4859 "--git-dir=.",
4860 "symbolic-ref",
4861 "HEAD",
4862 `refs/heads/${baseBranch}`,
4863 ]);
4864
4865 const driver = yield* GitVcsDriver.GitVcsDriver;
4866 const worktreePath = NodePath.join(yield* makeTempDir("t3code-git-worktrees-"), "feature");
4867 yield* driver.createWorktree({
4868 cwd: repoDir,
4869 path: worktreePath,
4870 refName: baseBranch,
4871 newRefName: "feature/remote-base",
4872 baseRefName: baseBranch,
4873 });
4874 NodeFS.writeFileSync(NodePath.join(worktreePath, "feature.txt"), "feature\n");
4875 yield* runGit(worktreePath, ["add", "feature.txt"]);
4876 yield* runGit(worktreePath, ["commit", "-m", "Feature commit"]);
4877
4878 const peerDir = yield* makeTempDir("t3code-git-peer-");
4879 yield* runGit(peerDir, ["clone", remoteDir, "."]);
4880 yield* runGit(peerDir, ["config", "user.email", "peer@example.com"]);
4881 yield* runGit(peerDir, ["config", "user.name", "Peer User"]);
4882 NodeFS.writeFileSync(NodePath.join(peerDir, "remote.txt"), "remote\n");
4883 NodeFS.mkdirSync(NodePath.join(peerDir, ".github"));
4884 NodeFS.writeFileSync(
4885 NodePath.join(peerDir, ".github/pull_request_template.md"),
4886 "Updated main template",
4887 );
4888 yield* runGit(peerDir, ["add", "."]);
4889 yield* runGit(peerDir, ["commit", "-m", "Remote base commit"]);
4890 yield* runGit(peerDir, ["push", "origin", baseBranch]);
4891
4892 NodeFS.writeFileSync(NodePath.join(peerDir, "later-main.txt"), "unrelated\n");
4893 yield* runGit(peerDir, ["add", "later-main.txt"]);
4894 yield* runGit(peerDir, ["commit", "-m", "Later main commit"]);
4895 yield* runGit(peerDir, ["push", "origin", baseBranch]);
4896 yield* runGit(worktreePath, ["fetch", "origin"]);
4897 yield* runGit(worktreePath, ["rebase", `origin/${baseBranch}`]);
4898
4899 const preview = yield* driver.getReviewDiffPreview({ cwd: worktreePath });
4900 const changes = preview.sources.find((source) => source.kind === "branch-range")!;
4901 expect.soft(changes.files).toEqual([
4902 {
4903 path: "feature.txt",
4904 previousPath: null,
4905 changeType: "new",
4906 additions: 1,
4907 deletions: 0,
4908 },
4909 ]);
4910 yield* runGit(worktreePath, ["push", "-u", "origin", "feature/remote-base"]);
4911
4912 const generatedInputs: TextGeneration.PrContentGenerationInput[] = [];
4913 const { manager, providerCalls } = yield* makeManager({
4914 providerScenario: {
4915 prListSequence: [[], []],
4916 },
4917 textGeneration: {
4918 generatePrContent: (input) => {
4919 generatedInputs.push(input);
4920 return Effect.succeed({ title: "Feature PR", body: "Feature body" });
4921 },
4922 },
4923 });
4924
4925 const result = yield* runStackedAction(manager, {
4926 cwd: worktreePath,
4927 action: "create_pr",
4928 });
4929
4930 expect(result.pr.status).toBe("created");
4931 expect(generatedInputs).toHaveLength(1);
4932 const generated = generatedInputs[0]!;
4933 expect.soft(generated.baseBranch).toBe(baseBranch);
4934 expect.soft(generated.commitSummary.trim()).toMatch(/^[a-f0-9]+ Feature commit$/);
4935 expect.soft(generated.diffSummary).toContain("feature.txt");
4936 expect.soft(generated.diffSummary).toContain("1 file changed, 1 insertion(+)");
4937 expect.soft(generated.diffPatch).toContain("+feature");
4938 expect.soft(generated.diffPatch).not.toContain("remote.txt");
4939 expect.soft(generated.diffPatch).not.toContain("later-main.txt");
4940 expect.soft(generated.diffPatch).not.toContain("pull_request_template.md");
4941 expect.soft(generated.changeRequestTemplate).toBe("Updated main template");
4942 expect(
4943 created(providerCalls).some(
4944 (call) =>
4945 call.baseRefName === baseBranch && call.headSelector === "feature/remote-base",
4946 ),
4947 ).toBe(true);
4948 }),
4949 );
4950
4951 it.effect(
4952 "creates a new PR instead of reusing an unrelated fork PR with the same head branch",
4953 () =>
4954 Effect.gen(function* () {
4955 const repoDir = yield* makeTempDir("t3code-git-manager-");
4956 yield* initRepo(repoDir);
4957 yield* runGit(repoDir, ["checkout", "-b", "feature/no-fork-match"]);
4958 const remoteDir = yield* createBareRemote();
4959 yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
4960 NodeFS.writeFileSync(NodePath.join(repoDir, "changes.txt"), "change\n");
4961 yield* runGit(repoDir, ["add", "changes.txt"]);
4962 yield* runGit(repoDir, ["commit", "-m", "Feature commit"]);
4963 yield* runGit(repoDir, ["push", "-u", "origin", "feature/no-fork-match"]);
4964
4965 const { manager, providerCalls } = yield* makeManager({
4966 providerScenario: {
4967 prListSequence: [
4968 [
4969 {
4970 number: 1661,
4971 title: "Fork PR with same branch name",
4972 url: "https://github.com/pingdotgg/t3code/pull/1661",
4973 baseRefName: "main",
4974 headRefName: "feature/no-fork-match",
4975 state: "open",
4976 isCrossRepository: true,
4977 headRepositoryNameWithOwner: "lnieuwenhuis/t3code",
4978 headRepositoryOwnerLogin: "lnieuwenhuis",
4979 },
4980 ],
4981 [
4982 {
4983 number: 188,
4984 title: "Add stacked git actions",
4985 url: "https://github.com/pingdotgg/codething-mvp/pull/188",
4986 baseRefName: "main",
4987 headRefName: "feature/no-fork-match",
4988 state: "open",
4989 isCrossRepository: false,
4990 },
4991 ],
4992 ],
4993 },
4994 });
4995 const result = yield* runStackedAction(manager, {
4996 cwd: repoDir,
4997 action: "commit_push_pr",
4998 });
4999
5000 expect(result.pr.status).toBe("created");
Showing first 5,000 of 7,056 lines. View raw