fix(server): change request templates are followed for GitLab and Azure DevOps

apps/server/src/git/GitManager.test.ts

@@ -2624,22 +2624,17 @@ it.layer(layerGitManagerTest)("GitManager", (it) => {
         },
       ]);
       const calls: SourceControlHost.SourceControlProcessInput[] = [];
+      const host = TestSourceControlHost.layer({
+        process: {
+          run: (input) =>
+            Effect.sync(() => {
+              calls.push(input);
+              return fakeGhOutput(output);
+            }),
+        },
+      });
       const provider = yield* GitLabSourceControlProvider.make.pipe(
-        Effect.provide(
-          GitLabCli.layer.pipe(
-            Layer.provide(
-              TestSourceControlHost.layer({
-                process: {
-                  run: (input) =>
-                    Effect.sync(() => {
-                      calls.push(input);
-                      return fakeGhOutput(output);
-                    }),
-                },
-              }),
-            ),
-          ),
-        ),
+        Effect.provide(Layer.mergeAll(GitLabCli.layer.pipe(Layer.provide(host)), host)),
       );
       const { manager } = yield* makeManager({ sourceControlProvider: provider });
 
@@ -5072,6 +5067,59 @@ it.layer(layerGitManagerTest)("GitManager", (it) => {
     }),
   );
 
+  it.effect("passes a non-GitHub provider's change request template to content generation", () =>
+    Effect.gen(function* () {
+      const repoDir = yield* makeTempDir("t3code-git-manager-");
+      yield* initRepo(repoDir);
+      const remoteDir = yield* createBareRemote();
+      yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+      yield* runGit(repoDir, ["checkout", "-b", "feature-gitlab-template"]);
+      NodeFS.writeFileSync(NodePath.join(repoDir, "changes.txt"), "change\n");
+      yield* runGit(repoDir, ["add", "changes.txt"]);
+      yield* runGit(repoDir, ["commit", "-m", "Feature commit"]);
+      yield* runGit(repoDir, ["push", "-u", "origin", "feature-gitlab-template"]);
+      yield* runGit(repoDir, ["config", "branch.feature-gitlab-template.gh-merge-base", "main"]);
+      let generatedChangeRequestTemplate: string | undefined;
+      const templateReads: Array<{ cwd: string; treeish: string }> = [];
+      const { service: fakeProvider } = createGitHubProviderWithFakeGh({
+        prListSequence: [
+          "[]",
+          JSON.stringify([
+            {
+              number: 5,
+              title: "Template follows the host",
+              url: "https://gitlab.com/group/project/-/merge_requests/5",
+              baseRefName: "main",
+              headRefName: "feature-gitlab-template",
+            },
+          ]),
+        ],
+      });
+
+      const { manager } = yield* makeManager({
+        sourceControlProvider: {
+          ...fakeProvider,
+          kind: SourceControlProviderKind.make("gitlab"),
+          readChangeRequestTemplate: (input) =>
+            Effect.sync(() => {
+              templateReads.push(input);
+              return Option.some("## Merge request checklist");
+            }),
+        },
+        textGeneration: {
+          generatePrContent: (input) => {
+            generatedChangeRequestTemplate = input.changeRequestTemplate;
+            return Effect.succeed({ title: "Template follows the host", body: "Body" });
+          },
+        },
+      });
+      yield* runStackedAction(manager, { cwd: repoDir, action: "commit_push_pr" });
+
+      expect(generatedChangeRequestTemplate).toBe("## Merge request checklist");
+      expect(templateReads).toHaveLength(1);
+    }),
+  );
+
   it.effect("generates PR content from branch changes when the remote base advances", () =>
     Effect.gen(function* () {
       const repoDir = yield* makeTempDir("t3code-git-manager-");

apps/server/src/sourceControl/gitLabAzureDevOpsChangeRequestTemplate.test.ts

@@ -0,0 +1,224 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+
+import * as ServerConfig from "../config.ts";
+import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
+import * as VcsProcess from "../vcs/VcsProcess.ts";
+import * as AzureDevOpsCli from "@t3tools/source-control-azure-devops/server/AzureDevOpsCli";
+import * as AzureDevOpsSourceControlProvider from "@t3tools/source-control-azure-devops/server/AzureDevOpsSourceControlProvider";
+import * as GitLabCli from "@t3tools/source-control-gitlab/server/GitLabCli";
+import * as GitLabSourceControlProvider from "@t3tools/source-control-gitlab/server/GitLabSourceControlProvider";
+import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";
+
+const layerTest = GitVcsDriver.layer.pipe(
+  Layer.provide(
+    ServerConfig.layerTest(process.cwd(), {
+      prefix: "t3-change-request-template-test-",
+    }),
+  ),
+  Layer.provideMerge(VcsProcess.layer),
+  Layer.provideMerge(NodeServices.layer),
+);
+
+const runGit = (cwd: string, args: ReadonlyArray<string>) =>
+  Effect.gen(function* () {
+    const git = yield* GitVcsDriver.GitVcsDriver;
+    return yield* git.execute({
+      operation: "changeRequestTemplate.test.runGit",
+      cwd,
+      args,
+    });
+  });
+
+const runWithTempDirectory = <A, E, R>(
+  test: (cwd: string) => Effect.Effect<A, E, R | FileSystem.FileSystem | Path.Path>,
+) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-change-request-" });
+      yield* runGit(cwd, ["init", "--initial-branch=main"]);
+      yield* runGit(cwd, ["config", "user.email", "test@example.com"]);
+      yield* runGit(cwd, ["config", "user.name", "Test User"]);
+      return yield* test(cwd);
+    }),
+  ).pipe(Effect.provide(layerTest));
+
+const writeFile = (cwd: string, relativePath: string, contents: string) =>
+  Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const filePath = path.join(cwd, relativePath);
+    yield* fileSystem.makeDirectory(path.dirname(filePath), { recursive: true });
+    yield* fileSystem.writeFileString(filePath, contents);
+  });
+
+const commitAll = (cwd: string) =>
+  Effect.gen(function* () {
+    yield* runGit(cwd, ["add", "-A"]);
+    yield* runGit(cwd, ["commit", "--allow-empty", "-m", "Add templates"]);
+  });
+
+// Each provider is built with test layers for its CLI and host only. The host's git is the real
+// driver, so templates are read from real commits.
+const detectGitLab = (cwd: string, treeish = "HEAD") =>
+  Effect.gen(function* () {
+    const git = yield* GitVcsDriver.GitVcsDriver;
+    const provider = yield* GitLabSourceControlProvider.make.pipe(
+      Effect.provide(
+        Layer.mergeAll(
+          Layer.mock(GitLabCli.GitLabCli)({}),
+          TestSourceControlHost.layer({ git: { execute: git.execute } }),
+        ),
+      ),
+    );
+    return Option.getOrUndefined(yield* provider.readChangeRequestTemplate!({ cwd, treeish }));
+  });
+
+const detectAzureDevOps = (cwd: string, treeish = "HEAD") =>
+  Effect.gen(function* () {
+    const git = yield* GitVcsDriver.GitVcsDriver;
+    const provider = yield* AzureDevOpsSourceControlProvider.make.pipe(
+      Effect.provide(
+        Layer.mergeAll(
+          Layer.mock(AzureDevOpsCli.AzureDevOpsCli)({}),
+          TestSourceControlHost.layer({ git: { execute: git.execute } }),
+        ),
+      ),
+    );
+    return Option.getOrUndefined(yield* provider.readChangeRequestTemplate!({ cwd, treeish }));
+  });
+
+const MERGE_REQUEST_TEMPLATES = ".gitlab/merge_request_templates";
+
+it.effect.each(["Default.md", "default.md", "DEFAULT.MD"])("GitLab recognizes %s", (name) =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, `${MERGE_REQUEST_TEMPLATES}/${name}`, "## GitLab default\n");
+      yield* commitAll(cwd);
+
+      assert.strictEqual(yield* detectGitLab(cwd), "## GitLab default");
+    }),
+  ),
+);
+
+it.effect("GitLab prefers Default.md over the other templates in the directory", () =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, `${MERGE_REQUEST_TEMPLATES}/Bugfix.md`, "bugfix template");
+      yield* writeFile(cwd, `${MERGE_REQUEST_TEMPLATES}/Default.md`, "default template");
+      yield* writeFile(cwd, `${MERGE_REQUEST_TEMPLATES}/Feature.md`, "feature template");
+      yield* commitAll(cwd);
+
+      assert.strictEqual(yield* detectGitLab(cwd), "default template");
+    }),
+  ),
+);
+
+it.effect("GitLab does not treat a lone non-default template as the default", () =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, `${MERGE_REQUEST_TEMPLATES}/Bugfix.md`, "bugfix template");
+      // Another host's template location is not GitLab's.
+      yield* writeFile(cwd, ".github/pull_request_template.md", "github template");
+      yield* commitAll(cwd);
+
+      assert.isUndefined(yield* detectGitLab(cwd));
+    }),
+  ),
+);
+
+it.effect("GitLab reads the template from the requested base tree", () =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, "README.md", "initial\n");
+      yield* commitAll(cwd);
+      yield* runGit(cwd, ["branch", "feature"]);
+      yield* writeFile(cwd, `${MERGE_REQUEST_TEMPLATES}/Default.md`, "base template");
+      yield* commitAll(cwd);
+      yield* runGit(cwd, ["checkout", "feature"]);
+
+      assert.isUndefined(yield* detectGitLab(cwd));
+      assert.strictEqual(yield* detectGitLab(cwd, "main"), "base template");
+    }),
+  ),
+);
+
+const AZURE_DEVOPS_TEMPLATE_PATHS = [
+  ".azuredevops/pull_request_template.md",
+  ".azuredevops/pull_request_template.txt",
+  ".vsts/pull_request_template.md",
+  "docs/pull_request_template.md",
+  "pull_request_template.md",
+  "pull_request_template.txt",
+] as const;
+
+it.effect.each(AZURE_DEVOPS_TEMPLATE_PATHS)("Azure DevOps recognizes %s", (relativePath) =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, relativePath, `template from ${relativePath}`);
+      yield* commitAll(cwd);
+
+      assert.strictEqual(yield* detectAzureDevOps(cwd), `template from ${relativePath}`);
+    }),
+  ),
+);
+
+it.effect("Azure DevOps uses the first location in its documented order", () =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, "pull_request_template.md", "root template");
+      yield* writeFile(cwd, "docs/pull_request_template.md", "docs template");
+      yield* writeFile(cwd, ".vsts/pull_request_template.md", "vsts template");
+      yield* writeFile(cwd, ".azuredevops/pull_request_template.md", "azuredevops template");
+      yield* commitAll(cwd);
+
+      assert.strictEqual(yield* detectAzureDevOps(cwd), "azuredevops template");
+    }),
+  ),
+);
+
+it.effect("Azure DevOps skips a blank template and falls through to the next location", () =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, ".azuredevops/pull_request_template.md", " \n");
+      yield* writeFile(cwd, "pull_request_template.md", "root template");
+      yield* commitAll(cwd);
+
+      assert.strictEqual(yield* detectAzureDevOps(cwd), "root template");
+    }),
+  ),
+);
+
+it.effect("Azure DevOps ignores GitHub and GitLab template locations", () =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, ".github/pull_request_template.md", "github template");
+      yield* writeFile(cwd, `${MERGE_REQUEST_TEMPLATES}/Default.md`, "gitlab template");
+      yield* commitAll(cwd);
+
+      assert.isUndefined(yield* detectAzureDevOps(cwd));
+    }),
+  ),
+);
+
+it.effect("Azure DevOps reads the template from the requested base tree", () =>
+  runWithTempDirectory((cwd) =>
+    Effect.gen(function* () {
+      yield* writeFile(cwd, "README.md", "initial\n");
+      yield* commitAll(cwd);
+      yield* runGit(cwd, ["branch", "feature"]);
+      yield* writeFile(cwd, ".azuredevops/pull_request_template.md", "base template");
+      yield* commitAll(cwd);
+      yield* runGit(cwd, ["checkout", "feature"]);
+
+      assert.isUndefined(yield* detectAzureDevOps(cwd));
+      assert.strictEqual(yield* detectAzureDevOps(cwd, "main"), "base template");
+    }),
+  ),
+);

packages/source-control-azure-devops/package.json

@@ -7,6 +7,10 @@
       "types": "./src/client/definition.ts",
       "import": "./src/client/definition.ts"
     },
+    "./server/azureDevOpsChangeRequestTemplate": {
+      "types": "./src/server/azureDevOpsChangeRequestTemplate.ts",
+      "import": "./src/server/azureDevOpsChangeRequestTemplate.ts"
+    },
     "./server/AzureDevOpsCli": {
       "types": "./src/server/AzureDevOpsCli.ts",
       "import": "./src/server/AzureDevOpsCli.ts"

packages/source-control-azure-devops/src/server/AzureDevOpsSourceControlProvider.test.ts

@@ -3,13 +3,20 @@ import { assert, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import { ChildProcessSpawner } from "effect/process";
 
+import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";
 import * as AzureDevOpsCli from "./AzureDevOpsCli.ts";
 import * as AzureDevOpsSourceControlProvider from "./AzureDevOpsSourceControlProvider.ts";
 
 function makeProvider(azure: Partial<AzureDevOpsCli.AzureDevOpsCli["Service"]>) {
   return AzureDevOpsSourceControlProvider.make.pipe(
-    Effect.provide(Layer.mock(AzureDevOpsCli.AzureDevOpsCli)(azure)),
+    Effect.provide(
+      Layer.mergeAll(
+        Layer.mock(AzureDevOpsCli.AzureDevOpsCli)(azure),
+        TestSourceControlHost.layer(),
+      ),
+    ),
   );
 }
 
@@ -120,3 +127,32 @@ it.effect("creates Azure DevOps PRs through provider-neutral input names", () =>
     });
   }),
 );
+
+it.effect("reads the change request template through the host's git", () =>
+  Effect.gen(function* () {
+    const gitArgs: Array<ReadonlyArray<string>> = [];
+    const host = TestSourceControlHost.layer({
+      git: {
+        execute: (input) =>
+          Effect.sync(() => {
+            gitArgs.push(input.args);
+            return {
+              exitCode: ChildProcessSpawner.ExitCode(0),
+              stdout: "",
+              stderr: "",
+              stdoutTruncated: false,
+              stderrTruncated: false,
+            };
+          }),
+      },
+    });
+    const provider = yield* AzureDevOpsSourceControlProvider.make.pipe(
+      Effect.provide(Layer.mergeAll(Layer.mock(AzureDevOpsCli.AzureDevOpsCli)({}), host)),
+    );
+
+    const template = yield* provider.readChangeRequestTemplate!({ cwd: "/repo", treeish: "main" });
+
+    assert.isTrue(Option.isNone(template));
+    assert.deepStrictEqual(gitArgs[0]?.slice(0, 5), ["ls-tree", "-r", "-z", "--full-tree", "main"]);
+  }),
+);