repokeeper 0.1.0

package/dist/modules/commits.js

@@ -0,0 +1,35 @@
+import { MANAGED_HEADER } from "../model.js";
+import { TOOL_VERSIONS } from "../version.js";
+const COMMITLINT_CONFIG = `// ${MANAGED_HEADER}
+export default {
+  extends: ["@commitlint/config-conventional"],
+  rules: {
+    "header-max-length": [2, "always", 100],
+  },
+};
+`;
+export const commitsModule = {
+    id: "commits",
+    enabled: (config) => config.modules.commits,
+    outputs(ctx) {
+        const outputs = [
+            { kind: "file", module: "commits", path: "commitlint.config.mjs", content: COMMITLINT_CONFIG },
+        ];
+        if (ctx.stacks.some((s) => s.id === "node")) {
+            outputs.push({
+                kind: "json",
+                module: "commits",
+                path: "package.json",
+                keyPath: ["devDependencies", "@commitlint/cli"],
+                value: `^${TOOL_VERSIONS.commitlintCli}`,
+            }, {
+                kind: "json",
+                module: "commits",
+                path: "package.json",
+                keyPath: ["devDependencies", "@commitlint/config-conventional"],
+                value: `^${TOOL_VERSIONS.commitlintConventional}`,
+            });
+        }
+        return outputs;
+    },
+};

package/dist/modules/deps.js

@@ -0,0 +1,5 @@
+export const depsModule = {
+    id: "deps",
+    enabled: (config) => config.modules.deps,
+    outputs: (ctx) => ctx.platform.dependencyUpdates(ctx.stacks.flatMap((s) => s.dependabot)),
+};

package/dist/modules/editorconfig.js

@@ -0,0 +1,44 @@
+import { MANAGED_HEADER } from "../model.js";
+const EDITORCONFIG = `# ${MANAGED_HEADER}
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[*.{cs,csx,vb,fs,fsx,fsi,py}]
+indent_size = 4
+
+[*.{ps1,psm1,bat,cmd}]
+end_of_line = crlf
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab
+`;
+const GITATTRIBUTES = [
+    "* text=auto eol=lf",
+    "*.{ps1,psm1,bat,cmd} text eol=crlf",
+    "*.{png,jpg,jpeg,gif,ico,webp,pdf,zip,gz,woff,woff2} binary",
+].join("\n");
+export const editorconfigModule = {
+    id: "editorconfig",
+    enabled: (config) => config.modules.editorconfig,
+    outputs: () => [
+        { kind: "file", module: "editorconfig", path: ".editorconfig", content: EDITORCONFIG },
+        {
+            kind: "block",
+            module: "editorconfig",
+            path: ".gitattributes",
+            id: "editorconfig",
+            comment: "hash",
+            body: GITATTRIBUTES,
+        },
+    ],
+};

package/dist/modules/gitignore.js

@@ -0,0 +1,20 @@
+import { readTemplate } from "../templates.js";
+export const gitignoreModule = {
+    id: "gitignore",
+    enabled: (config) => config.modules.gitignore,
+    outputs(ctx) {
+        const names = [...new Set(ctx.stacks.flatMap((s) => s.gitignore))];
+        const sections = names.map((n) => `## ${n} (github/gitignore)\n${readTemplate(`gitignore/${n}.gitignore`).trim()}`);
+        sections.push("## repokeeper\n*.repokeeper-new");
+        return [
+            {
+                kind: "block",
+                module: "gitignore",
+                path: ".gitignore",
+                id: "gitignore",
+                comment: "hash",
+                body: sections.join("\n\n"),
+            },
+        ];
+    },
+};

package/dist/modules/health.js

@@ -0,0 +1,58 @@
+import { UsageError } from "../errors.js";
+import { MANAGED_HEADER } from "../model.js";
+import { readTemplate } from "../templates.js";
+import { TOOL_VERSIONS } from "../version.js";
+const MIT = (holder) => `MIT License
+
+Copyright (c) ${holder}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+const md = (path, content) => ({ kind: "file", module: "health", path, content });
+export const healthModule = {
+    id: "health",
+    enabled: (config) => config.modules.health !== false,
+    outputs(ctx) {
+        const health = ctx.config.modules.health;
+        if (!health)
+            return [];
+        const { owner, name } = ctx.repo;
+        const outputs = [];
+        if (health.license !== false) {
+            if (health.license !== "MIT") {
+                throw new UsageError(`license ${health.license} is not bundled with this version of repokeeper; use MIT, or set modules.health.license to false`);
+            }
+            outputs.push(md("LICENSE", MIT(health.copyright)));
+        }
+        const report = owner
+            ? `through [GitHub security advisories](https://github.com/${owner}/${name}/security/advisories/new)`
+            : "through the repository's Security tab (Report a vulnerability)";
+        outputs.push(md("SECURITY.md", `# Security Policy\n\n<!-- ${MANAGED_HEADER} -->\n\n## Supported versions\n\nSecurity fixes are released for the latest published version.\n\n## Reporting a vulnerability\n\nPlease do not open a public issue. Report the vulnerability privately ${report}.\nThe maintainers will acknowledge it as soon as possible and keep you informed until it is resolved.\n`));
+        const install = ctx.stacks.map((s) => s.install).filter((c) => c !== null);
+        const run = install.length ? `Run ${install.map((c) => `\`${c}\``).join(" and ")}.` : "";
+        const hooks = ctx.stacks.some((s) => s.id === "node")
+            ? "Installing the dependencies also installs the git hooks (lefthook)."
+            : `Then run \`npx --yes lefthook@${TOOL_VERSIONS.lefthook} install\` once to enable the git hooks (they need Node.js 22 or newer).`;
+        const setup = [run, hooks].filter(Boolean).join(" ");
+        outputs.push(md("CONTRIBUTING.md", `# Contributing\n\n<!-- ${MANAGED_HEADER} -->\n\nThanks for helping improve this project.\n\n## Local setup\n\n${setup}\n\n## Workflow\n\n1. Create a branch from \`main\`.\n2. Write commit messages in [Conventional Commits](https://www.conventionalcommits.org/) form, for example \`feat: add export button\` or \`fix(api): handle empty input\`. The \`commit-msg\` hook checks them.\n3. Open a pull request. It is merged once the checks pass and it has been reviewed.\n\nPlease follow the [Code of Conduct](CODE_OF_CONDUCT.md).\n`));
+        outputs.push(md("CODE_OF_CONDUCT.md", readTemplate("CODE_OF_CONDUCT.md").replace("[INSERT CONTACT METHOD]", health.contact)));
+        outputs.push(...ctx.platform.communityFiles(ctx));
+        return outputs;
+    },
+};

package/dist/modules/hooks.js

@@ -0,0 +1,41 @@
+import { stringify } from "yaml";
+import { MANAGED_HEADER } from "../model.js";
+import { TOOL_VERSIONS } from "../version.js";
+export const hooksModule = {
+    id: "hooks",
+    enabled: (config) => config.modules.hooks,
+    outputs(ctx) {
+        const config = {};
+        const preCommit = ctx.stacks.flatMap((s) => s.staged).map((job) => ({ ...job, stage_fixed: true }));
+        if (preCommit.length > 0)
+            config["pre-commit"] = { parallel: true, jobs: preCommit };
+        if (ctx.config.modules.commits) {
+            const node = ctx.stacks.some((s) => s.id === "node");
+            const commitlint = node
+                ? "npx --no-install commitlint --edit {1}"
+                : `npx --yes --package @commitlint/cli@${TOOL_VERSIONS.commitlintCli} --package @commitlint/config-conventional@${TOOL_VERSIONS.commitlintConventional} -- commitlint --edit {1}`;
+            config["commit-msg"] = { jobs: [{ name: "commitlint", run: commitlint }] };
+        }
+        const prePush = ctx.stacks.flatMap((s) => (s.test ? [{ name: `${s.id}:test`, run: s.test }] : []));
+        if (prePush.length > 0)
+            config["pre-push"] = { jobs: prePush };
+        const outputs = [
+            {
+                kind: "file",
+                module: "hooks",
+                path: "lefthook.yml",
+                content: `# ${MANAGED_HEADER}\n${stringify(config, { lineWidth: 0 })}`,
+            },
+        ];
+        if (ctx.stacks.some((s) => s.id === "node")) {
+            outputs.push({
+                kind: "json",
+                module: "hooks",
+                path: "package.json",
+                keyPath: ["devDependencies", "lefthook"],
+                value: `^${TOOL_VERSIONS.lefthook}`,
+            });
+        }
+        return outputs;
+    },
+};

package/dist/modules/index.js

@@ -0,0 +1,18 @@
+import { ciModule } from "./ci.js";
+import { commitsModule } from "./commits.js";
+import { depsModule } from "./deps.js";
+import { editorconfigModule } from "./editorconfig.js";
+import { gitignoreModule } from "./gitignore.js";
+import { healthModule } from "./health.js";
+import { hooksModule } from "./hooks.js";
+import { releaseModule } from "./release.js";
+export const MODULES = [
+    editorconfigModule,
+    gitignoreModule,
+    commitsModule,
+    hooksModule,
+    healthModule,
+    depsModule,
+    ciModule,
+    releaseModule,
+];

package/dist/modules/release.js

@@ -0,0 +1,10 @@
+/** One release per repository: the first stack with a language release type wins, otherwise the first stack's `simple` release (which may name extra files). */
+export function pickRelease(stacks) {
+    const language = stacks.find((stack) => stack.release.type !== "simple");
+    return language?.release ?? stacks[0]?.release ?? { type: "simple", version: null };
+}
+export const releaseModule = {
+    id: "release",
+    enabled: (config) => config.modules.release,
+    outputs: (ctx) => ctx.platform.releaseAutomation(ctx, pickRelease(ctx.stacks)),
+};

package/dist/plan.js

@@ -0,0 +1,19 @@
+import { outputId } from "./model.js";
+import { MODULES } from "./modules/index.js";
+const toPosix = (path) => path.replace(/\\/g, "/").replace(/^\.\//, "");
+/** Pure: the outputs the standard asks for, given the config and resolved stacks. */
+export function planOutputs(ctx, modules = MODULES) {
+    const owned = new Set(ctx.config.owned.map(toPosix));
+    const outputs = modules
+        .filter((module) => module.enabled(ctx.config))
+        .flatMap((module) => module.outputs(ctx))
+        .filter((output) => !owned.has(output.path));
+    const seen = new Set();
+    for (const output of outputs) {
+        const id = outputId(output);
+        if (seen.has(id))
+            throw new Error(`two modules produce ${id}`);
+        seen.add(id);
+    }
+    return outputs.sort((a, b) => outputId(a).localeCompare(outputId(b)));
+}

package/dist/platforms/github.js

@@ -0,0 +1,168 @@
+import { stringify } from "yaml";
+import { MANAGED_HEADER } from "../model.js";
+import { REUSABLE_REPO, WORKFLOW_REF } from "../version.js";
+const yamlFile = (module, path, data) => ({
+    kind: "file",
+    module,
+    path,
+    content: `# ${MANAGED_HEADER}\n${stringify(data)}`,
+});
+const WORKFLOW_KEYS = ["name", "on", "permissions", "concurrency", "env", "defaults", "jobs"];
+/** Reference to a reusable workflow; local inside the repository that hosts them. */
+function workflowRef(ctx, file) {
+    const self = ctx.repo.owner !== null && `${ctx.repo.owner}/${ctx.repo.name}` === REUSABLE_REPO;
+    return self ? `./.github/workflows/${file}` : `${REUSABLE_REPO}/.github/workflows/${file}@${WORKFLOW_REF}`;
+}
+const workflowKey = (module, path, keyPath, value) => ({
+    kind: "yaml",
+    module,
+    path,
+    keyPath,
+    value,
+    order: WORKFLOW_KEYS,
+});
+function defaultBranch(ctx) {
+    const branch = ctx.config.github?.default_branch;
+    return typeof branch === "string" && branch.length > 0 ? branch : "main";
+}
+const RELEASE_PLEASE_SCHEMA = "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json";
+const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+export const githubPlatform = {
+    id: "github",
+    communityFiles(ctx) {
+        const { owner, name } = ctx.repo;
+        const outputs = [
+            yamlFile("health", ".github/ISSUE_TEMPLATE/bug_report.yml", {
+                name: "Bug report",
+                description: "Report something that does not work as expected",
+                labels: ["bug"],
+                body: [
+                    {
+                        type: "textarea",
+                        id: "what-happened",
+                        attributes: { label: "What happened?", description: "Include the steps to reproduce it." },
+                        validations: { required: true },
+                    },
+                    {
+                        type: "textarea",
+                        id: "expected",
+                        attributes: { label: "What did you expect?" },
+                        validations: { required: true },
+                    },
+                    { type: "input", id: "version", attributes: { label: "Version" } },
+                ],
+            }),
+            yamlFile("health", ".github/ISSUE_TEMPLATE/feature_request.yml", {
+                name: "Feature request",
+                description: "Suggest an improvement",
+                labels: ["enhancement"],
+                body: [
+                    {
+                        type: "textarea",
+                        id: "problem",
+                        attributes: { label: "What problem would this solve?" },
+                        validations: { required: true },
+                    },
+                    { type: "textarea", id: "proposal", attributes: { label: "What do you propose?" } },
+                ],
+            }),
+            yamlFile("health", ".github/ISSUE_TEMPLATE/config.yml", {
+                blank_issues_enabled: false,
+                contact_links: owner
+                    ? [
+                        {
+                            name: "Report a security vulnerability",
+                            url: `https://github.com/${owner}/${name}/security/advisories/new`,
+                            about: "Please report vulnerabilities privately.",
+                        },
+                    ]
+                    : [],
+            }),
+            {
+                kind: "file",
+                module: "health",
+                path: ".github/pull_request_template.md",
+                content: `<!-- ${MANAGED_HEADER} -->\n\n## Summary\n\n## Testing\n\n- [ ] Tests added or updated\n- [ ] Commit messages follow Conventional Commits\n`,
+            },
+        ];
+        const health = ctx.config.modules.health;
+        if (health && health.codeowners.length > 0) {
+            outputs.push({
+                kind: "file",
+                module: "health",
+                path: ".github/CODEOWNERS",
+                content: `# ${MANAGED_HEADER}\n* ${health.codeowners.join(" ")}\n`,
+            });
+        }
+        return outputs;
+    },
+    dependencyUpdates(ecosystems) {
+        const updates = [...new Set([...ecosystems, "github-actions"])].map((ecosystem) => ({
+            "package-ecosystem": ecosystem,
+            directory: "/",
+            schedule: { interval: "weekly" },
+            groups: { [`${ecosystem}-minor-and-patch`]: { "update-types": ["minor", "patch"] } },
+        }));
+        return [yamlFile("deps", ".github/dependabot.yml", { version: 2, updates })];
+    },
+    ciWorkflow(ctx) {
+        const path = ".github/workflows/ci.yml";
+        const jobs = [];
+        for (const stack of ctx.stacks) {
+            if (stack.ci) {
+                jobs.push(workflowKey("ci", path, ["jobs", stack.id], {
+                    uses: workflowRef(ctx, stack.ci.workflow),
+                    with: stack.ci.with,
+                }));
+            }
+        }
+        if (ctx.config.modules.commits) {
+            jobs.push(workflowKey("ci", path, ["jobs", "commits"], { uses: workflowRef(ctx, "commitlint.yml") }));
+        }
+        if (jobs.length === 0)
+            return [];
+        return [
+            workflowKey("ci", path, ["name"], "ci"),
+            workflowKey("ci", path, ["on"], { pull_request: null, push: { branches: [defaultBranch(ctx)] } }),
+            workflowKey("ci", path, ["permissions"], { contents: "read" }),
+            ...jobs,
+        ];
+    },
+    releaseAutomation(ctx, release) {
+        const path = ".github/workflows/release.yml";
+        return [
+            {
+                kind: "file",
+                module: "release",
+                path: "release-please-config.json",
+                content: json({
+                    $schema: RELEASE_PLEASE_SCHEMA,
+                    packages: {
+                        ".": {
+                            "release-type": release.type,
+                            "changelog-path": "CHANGELOG.md",
+                            "bump-minor-pre-major": true,
+                            "include-component-in-tag": false,
+                            ...(release.extraFiles && release.extraFiles.length > 0 ? { "extra-files": release.extraFiles } : {}),
+                        },
+                    },
+                }),
+            },
+            {
+                kind: "seed",
+                module: "release",
+                path: ".release-please-manifest.json",
+                content: json({ ".": release.version ?? "0.0.0" }),
+            },
+            workflowKey("release", path, ["name"], "release"),
+            workflowKey("release", path, ["on"], { push: { branches: [defaultBranch(ctx)] } }),
+            workflowKey("release", path, ["permissions"], { contents: "read" }),
+            workflowKey("release", path, ["jobs", "release"], {
+                uses: workflowRef(ctx, "release-please.yml"),
+                permissions: { contents: "write", "pull-requests": "write", issues: "write" },
+                // biome-ignore lint/suspicious/noTemplateCurlyInString: a GitHub Actions expression, not a JS template
+                secrets: { token: "${{ secrets.RELEASE_PLEASE_TOKEN }}" },
+            }),
+        ];
+    },
+};

package/dist/stacks/dart.js

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { checkKeys, readText, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+export const dartStack = {
+    id: "dart",
+    detect: (root) => existsSync(join(root, "pubspec.yaml")),
+    async resolve(root, options = {}) {
+        checkKeys("dart", options, OPTION_KEYS);
+        const pubspec = (await readText(root, "pubspec.yaml")) ?? "";
+        const flutter = /sdk:\s*flutter\b/.test(pubspec);
+        const tool = flutter ? "flutter" : "dart";
+        const test = existsSync(join(root, "test")) ? `${tool} test` : null;
+        const commands = ["dart format --output=none --set-exit-if-changed .", `${tool} analyze`, ...(test ? [test] : [])];
+        return {
+            id: "dart",
+            staged: [{ name: "dart:format", glob: "*.dart", run: "dart format {staged_files}" }],
+            test,
+            install: `${tool} pub get`,
+            gitignore: ["Dart"],
+            dependabot: ["pub"],
+            ci: {
+                workflow: "stack-dart.yml",
+                with: {
+                    "sdk-versions": JSON.stringify(stringList("dart", options, "versions") ?? ["stable"]),
+                    os: JSON.stringify(stringList("dart", options, "os") ?? ["ubuntu-latest"]),
+                    flutter: String(flutter),
+                    "install-command": `${tool} pub get`,
+                    commands: JSON.stringify(commands),
+                },
+            },
+            release: { type: "dart", version: /^version:\s*(\S+)/m.exec(pubspec)?.[1] ?? null },
+        };
+    },
+};

package/dist/stacks/dotnet.js

@@ -0,0 +1,47 @@
+import { checkKeys, filesMatching, readText, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+const SOLUTIONS = /\.(sln|slnx)$/;
+const PROJECTS = /\.(csproj|fsproj|vbproj)$/;
+const VERSION_XPATH = "//Project/PropertyGroup/Version";
+const versionOf = (xml) => (xml ? (/<Version>\s*([^<\s]+)\s*<\/Version>/.exec(xml)?.[1] ?? null) : null);
+export const dotnetStack = {
+    id: "dotnet",
+    detect: (root) => filesMatching(root, ".", SOLUTIONS).length + filesMatching(root, ".", PROJECTS).length > 0,
+    async resolve(root, options = {}) {
+        checkKeys("dotnet", options, OPTION_KEYS);
+        const solutions = filesMatching(root, ".", SOLUTIONS);
+        const projects = filesMatching(root, ".", PROJECTS);
+        // with several entries at the root, dotnet stops with MSB1011 unless one is named
+        const target = solutions.length + projects.length > 1 ? ` ${solutions[0] ?? projects[0]}` : "";
+        let release = { type: "simple", version: null };
+        for (const file of ["Directory.Build.props", ...(projects.length === 1 ? projects : [])]) {
+            const version = versionOf(await readText(root, file));
+            if (version) {
+                release = { type: "simple", version, extraFiles: [{ type: "xml", path: file, xpath: VERSION_XPATH }] };
+                break;
+            }
+        }
+        return {
+            id: "dotnet",
+            staged: [{ name: "dotnet:format", glob: "*.{cs,vb,fs}", run: `dotnet format${target} --include {staged_files}` }],
+            test: `dotnet test${target}`,
+            install: `dotnet restore${target}`,
+            gitignore: ["VisualStudio"],
+            dependabot: ["nuget"],
+            ci: {
+                workflow: "stack-dotnet.yml",
+                with: {
+                    "dotnet-versions": JSON.stringify(stringList("dotnet", options, "versions") ?? ["8.0", "9.0"]),
+                    os: JSON.stringify(stringList("dotnet", options, "os") ?? ["ubuntu-latest"]),
+                    commands: JSON.stringify([
+                        `dotnet restore${target}`,
+                        `dotnet format${target} --verify-no-changes --no-restore`,
+                        `dotnet build${target} --no-restore`,
+                        `dotnet test${target} --no-build`,
+                    ]),
+                },
+            },
+            release,
+        };
+    },
+};

package/dist/stacks/index.js

@@ -0,0 +1,23 @@
+import { STACK_IDS } from "../config/types.js";
+import { dartStack } from "./dart.js";
+import { dotnetStack } from "./dotnet.js";
+import { javaStack } from "./java.js";
+import { nodeStack } from "./node.js";
+import { pythonStack } from "./python.js";
+import { scriptStack } from "./script.js";
+const PACKS = {
+    node: nodeStack,
+    python: pythonStack,
+    dart: dartStack,
+    script: scriptStack,
+    java: javaStack,
+    dotnet: dotnetStack,
+};
+export function getStackPack(id) {
+    return PACKS[id];
+}
+export async function detectStacks(root) {
+    const found = STACK_IDS.filter((id) => PACKS[id].detect(root));
+    // scripts beside another stack belong to that stack; the script pack is for script-only repositories
+    return found.length > 1 ? found.filter((id) => id !== "script") : found;
+}

package/dist/stacks/java.js

@@ -0,0 +1,52 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { checkKeys, readText, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os"];
+/** The project's own <version>: parent, dependency and plugin versions are removed first. */
+function mavenVersion(pom) {
+    const own = pom.replace(/<(parent|dependencies|dependencyManagement|build|profiles|reporting)>[\s\S]*?<\/\1>/g, "");
+    const version = /<version>\s*([^<\s]+)\s*<\/version>/.exec(own)?.[1];
+    return version && !version.includes("${") ? version : null;
+}
+export const javaStack = {
+    id: "java",
+    detect: (root) => ["pom.xml", "build.gradle", "build.gradle.kts"].some((f) => existsSync(join(root, f))),
+    async resolve(root, options = {}) {
+        checkKeys("java", options, OPTION_KEYS);
+        const has = (path) => existsSync(join(root, path));
+        const maven = has("pom.xml");
+        let command;
+        let release;
+        if (maven) {
+            command = has("mvnw") ? "./mvnw -B verify" : "mvn -B verify";
+            release = { type: "maven", version: mavenVersion((await readText(root, "pom.xml")) ?? "") };
+        }
+        else {
+            command = has("gradlew") ? "./gradlew check" : "gradle check";
+            const properties = await readText(root, "gradle.properties");
+            const version = properties ? (/^version\s*=\s*(\S+)/m.exec(properties)?.[1] ?? null) : null;
+            // release-please's generic updater changes gradle.properties once it carries x-release-please markers
+            release = { type: "simple", version, ...(properties !== null ? { extraFiles: ["gradle.properties"] } : {}) };
+        }
+        return {
+            id: "java",
+            // formatting runs through the build (Spotless), not per staged file
+            staged: [],
+            test: command,
+            install: null,
+            gitignore: ["Java", maven ? "Maven" : "Gradle"],
+            dependabot: [maven ? "maven" : "gradle"],
+            ci: {
+                workflow: "stack-java.yml",
+                with: {
+                    "java-versions": JSON.stringify(stringList("java", options, "versions") ?? ["17", "21"]),
+                    os: JSON.stringify(stringList("java", options, "os") ?? ["ubuntu-latest"]),
+                    "build-tool": maven ? "maven" : "gradle",
+                    "gradle-version": !maven && !has("gradlew") ? "current" : "",
+                    commands: JSON.stringify([command]),
+                },
+            },
+            release,
+        };
+    },
+};