repokeeper 0.5.0 → 0.7.0

package/dist/platforms/gitlab.js

@@ -1,6 +1,8 @@
-import { defaultBranch } from "../config/types.js";
-import { MANAGED_HEADER } from "../model.js";
+import { defaultBranch, STACK_IDS } from "../config/types.js";
+import { MANAGED_HEADER, } from "../model.js";
+import { releaseFiles } from "../release/bump.js";
 import { PACKAGE_VERSION, TOOL_VERSIONS } from "../version.js";
+import { FOR_CHANGES, NOT_SCHEDULED, STACK_JOB_KEYS, stackJobs } from "./gitlab-jobs.js";
 const md = (path, body) => ({
     kind: "file",
     module: "health",
@@ -10,7 +12,7 @@ const md = (path, body) => ({
 /** Web address of the GitLab instance the repository lives on. */
 const baseUrl = (repo) => `https://${repo.host ?? "gitlab.com"}`;
 const CI_FILE = ".gitlab-ci.yml";
-const CI_KEYS = ["workflow", "node", "commits", "repokeeper", "renovate", "release"];
+const CI_KEYS = ["workflow", "node", "go", ...STACK_JOB_KEYS, "commits", "repokeeper", "renovate", "release"];
 /** One managed top-level key of .gitlab-ci.yml; keys the user adds are left alone. */
 const ciKey = (module, key, value) => ({
     kind: "yaml",
@@ -20,9 +22,6 @@ const ciKey = (module, key, value) => ({
     value,
     order: CI_KEYS,
 });
-const NOT_SCHEDULED = '$CI_PIPELINE_SOURCE != "schedule"';
-/** The checks of a change: merge requests and the default branch, not schedules and not tag pipelines. */
-const FOR_CHANGES = `${NOT_SCHEDULED} && $CI_COMMIT_TAG == null`;
 /** Image of the jobs that only run tools, whatever Node.js versions the project tests on. */
 const TOOL_IMAGE = "node:24";
 /** The node stack's CI inputs, as the GitHub reusable workflow receives them, as a GitLab job. */
@@ -48,6 +47,22 @@ function nodeJob(input) {
         ],
     };
 }
+/**
+ * The go stack's CI inputs as a GitLab job. No module cache: it would have to live inside the project
+ * folder, where `gofmt -l .` would read it as the project's own code.
+ */
+function goJob(input) {
+    // setup-go's "stable" is the image's `latest` tag
+    const versions = JSON.parse(input["go-versions"] ?? '["stable"]').map((version) => version === "stable" ? "latest" : version);
+    return {
+        stage: "test",
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: a GitLab CI variable
+        image: "golang:${GO_VERSION}",
+        parallel: { matrix: [{ GO_VERSION: versions }] },
+        rules: [{ if: FOR_CHANGES }],
+        script: JSON.parse(input.commands ?? "[]"),
+    };
+}
 /** commitlint from a scratch directory, so the project needs no commitlint of its own. */
 const COMMITLINT = `dir="$(mktemp -d)"
 (cd "$dir" && echo '{ "private": true }' > package.json && npm install --no-audit --no-fund @commitlint/cli@${TOOL_VERSIONS.commitlintCli} @commitlint/config-conventional@${TOOL_VERSIONS.commitlintConventional})
@@ -68,14 +83,16 @@ const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
 /**
  * semantic-release and the plugins it does not bundle, from a scratch directory. It resolves plugins next to
  * itself before it looks in the project, so the project needs none of them installed.
+ *
+ * @param exec Whether the release runs a command of its own (the version bump of a stack npm does not know).
  */
-const SEMANTIC_RELEASE = `dir="$(mktemp -d)"
-(cd "$dir" && echo '{ "private": true }' > package.json && npm install --no-audit --no-fund semantic-release@${TOOL_VERSIONS.semanticRelease} @semantic-release/changelog@${TOOL_VERSIONS.semanticReleaseChangelog} @semantic-release/git@${TOOL_VERSIONS.semanticReleaseGit} @semantic-release/gitlab@${TOOL_VERSIONS.semanticReleaseGitlab} conventional-changelog-conventionalcommits@${TOOL_VERSIONS.conventionalCommitsPreset})
+const semanticRelease = (exec) => `dir="$(mktemp -d)"
+(cd "$dir" && echo '{ "private": true }' > package.json && npm install --no-audit --no-fund semantic-release@${TOOL_VERSIONS.semanticRelease} @semantic-release/changelog@${TOOL_VERSIONS.semanticReleaseChangelog} @semantic-release/git@${TOOL_VERSIONS.semanticReleaseGit} @semantic-release/gitlab@${TOOL_VERSIONS.semanticReleaseGitlab}${exec ? ` @semantic-release/exec@${TOOL_VERSIONS.semanticReleaseExec}` : ""} conventional-changelog-conventionalcommits@${TOOL_VERSIONS.conventionalCommitsPreset})
 "$dir/node_modules/.bin/semantic-release"
 `;
 export const gitlabPlatform = {
     id: "gitlab",
-    stacks: ["node"],
+    stacks: STACK_IDS,
     changeRequest: "merge request",
     profileUrl: (repo) => (repo.owner ? `${baseUrl(repo)}/${repo.owner}` : null),
     securityReport: (repo) => repo.owner
@@ -137,6 +154,13 @@ export const gitlabPlatform = {
         const node = ctx.stacks.find((stack) => stack.id === "node")?.ci;
         if (node)
             jobs.push(ciKey("ci", "node", nodeJob(node.with)));
+        const go = ctx.stacks.find((stack) => stack.id === "go")?.ci;
+        if (go)
+            jobs.push(ciKey("ci", "go", goJob(go.with)));
+        for (const stack of ctx.stacks) {
+            for (const { key, job } of stackJobs(stack))
+                jobs.push(ciKey("ci", key, job));
+        }
         if (ctx.config.modules.commits) {
             jobs.push(ciKey("ci", "commits", {
                 stage: "test",
@@ -170,8 +194,11 @@ export const gitlabPlatform = {
             ...jobs,
         ];
     },
-    releaseAutomation(ctx) {
+    releaseAutomation(ctx, release) {
         const branch = defaultBranch(ctx.config);
+        const npm = release.type === "node";
+        // the files of the other stacks that hold a version; none for a Go module, whose version is its tag
+        const versionFiles = npm ? [] : releaseFiles(release);
         return [
             {
                 kind: "file",
@@ -186,11 +213,24 @@ export const gitlabPlatform = {
                         ["@semantic-release/release-notes-generator", { preset: "conventionalcommits" }],
                         ["@semantic-release/changelog", { changelogFile: "CHANGELOG.md" }],
                         // bumps package.json and the npm lock file; publishing stays the project's own business
-                        ["@semantic-release/npm", { npmPublish: false }],
+                        ...(npm ? [["@semantic-release/npm", { npmPublish: false }]] : []),
+                        // semantic-release knows no other stack's version file; repokeeper writes the version into it
+                        ...(versionFiles.length > 0
+                            ? [
+                                [
+                                    "@semantic-release/exec",
+                                    { prepareCmd: `npx --yes repokeeper@${PACKAGE_VERSION} bump \${nextRelease.version}` },
+                                ],
+                            ]
+                            : []),
                         [
                             "@semantic-release/git",
                             {
-                                assets: ["CHANGELOG.md", "package.json", "package-lock.json", "npm-shrinkwrap.json"],
+                                assets: [
+                                    "CHANGELOG.md",
+                                    ...(npm ? ["package.json", "package-lock.json", "npm-shrinkwrap.json"] : []),
+                                    ...versionFiles,
+                                ],
                                 // biome-ignore lint/suspicious/noTemplateCurlyInString: a semantic-release template
                                 message: "chore(release): ${nextRelease.version} [skip ci]",
                             },
@@ -205,7 +245,7 @@ export const gitlabPlatform = {
                 image: TOOL_IMAGE,
                 rules: [{ if: `${NOT_SCHEDULED} && $CI_COMMIT_BRANCH == "${branch}" && $GITLAB_TOKEN` }],
                 variables: { GIT_DEPTH: "0" },
-                script: [SEMANTIC_RELEASE],
+                script: [semanticRelease(versionFiles.length > 0)],
             }),
         ];
     },

package/dist/release/bump.js

@@ -0,0 +1,223 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Writing a release's version into the files of a stack, for a release tool that has no updater per
+ * language: on GitHub release-please does this, on GitLab the release job runs `repokeeper bump`.
+ * Every function here takes the text of a file and returns it with the new version, or null when
+ * the file holds no version of the kind it looks for.
+ */
+const SEMVER = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?/;
+/** Replaces the first match of `pattern` in the body of the `[name]` table; group 1 is what precedes the version. */
+function inTomlTable(toml, name, pattern, version) {
+    const header = new RegExp(`^\\[${name.replace(/\./g, "\\.")}\\][^\\n]*$`, "m").exec(toml);
+    if (!header)
+        return null;
+    const start = header.index + header[0].length;
+    const next = /^\[/m.exec(toml.slice(start));
+    const end = next ? start + next.index : toml.length;
+    const body = toml.slice(start, end);
+    if (!pattern.test(body))
+        return null;
+    return toml.slice(0, start) + body.replace(pattern, `$1${version}$2`) + toml.slice(end);
+}
+const TOML_VERSION = /^(version\s*=\s*")[^"]*(")/m;
+/** `version` of `[project]`, or of `[tool.poetry]` for a Poetry project without one. */
+export function bumpPyproject(text, version) {
+    return inTomlTable(text, "project", TOML_VERSION, version) ?? inTomlTable(text, "tool.poetry", TOML_VERSION, version);
+}
+/** `version = x` of `[metadata]` in setup.cfg. */
+export function bumpSetupCfg(text, version) {
+    const header = /^\[metadata\][^\n]*$/m.exec(text);
+    if (!header)
+        return null;
+    const start = header.index + header[0].length;
+    const next = /^\[/m.exec(text.slice(start));
+    const end = next ? start + next.index : text.length;
+    const pattern = /^(version\s*=\s*)\S+/m;
+    const body = text.slice(start, end);
+    // `attr:` and `file:` read the version from elsewhere; there is nothing to write here
+    if (!pattern.test(body) || /^version\s*=\s*(attr|file):/m.test(body))
+        return null;
+    return text.slice(0, start) + body.replace(pattern, `$1${version}`) + text.slice(end);
+}
+/** The `version="x"` argument of `setup()` in setup.py. */
+export function bumpSetupPy(text, version) {
+    const pattern = /(\bversion\s*=\s*["'])[^"']*(["'])/;
+    return pattern.test(text) ? text.replace(pattern, `$1${version}$2`) : null;
+}
+/** `version:` of pubspec.yaml; a build number (`+4`) is kept and counted up, as stores require. */
+export function bumpPubspec(text, version) {
+    const match = /^(version:\s*)(\S+)/m.exec(text);
+    if (!match)
+        return null;
+    const build = /\+(\d+)$/.exec(match[2]);
+    const next = build ? `${version}+${Number(build[1]) + 1}` : version;
+    return text.replace(/^(version:\s*)\S+/m, `$1${next}`);
+}
+/** `version` of `[package]` in Cargo.toml, or of `[workspace.package]` when the package inherits it. */
+export function bumpCargoToml(text, version) {
+    return (inTomlTable(text, "package", TOML_VERSION, version) ?? inTomlTable(text, "workspace.package", TOML_VERSION, version));
+}
+/** The name of the crate at the root, for its entry in Cargo.lock. */
+export function cargoPackageName(cargoToml) {
+    const table = cargoToml.split(/^\[/m).find((part) => part.startsWith("package]")) ?? "";
+    return /^name\s*=\s*"([^"]+)"/m.exec(table)?.[1] ?? null;
+}
+/** The crate's own entry in Cargo.lock, which `cargo build --locked` compares with Cargo.toml. */
+export function bumpCargoLock(text, name, version) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`(\\[\\[package\\]\\]\\r?\\nname = "${escaped}"\\r?\\nversion = ")[^"]*(")`);
+    return pattern.test(text) ? text.replace(pattern, `$1${version}$2`) : null;
+}
+/** The top-level `version` of composer.json, when the project keeps one; Composer itself reads tags. */
+export function bumpComposer(text, version) {
+    let current;
+    try {
+        current = JSON.parse(text).version;
+    }
+    catch {
+        return null;
+    }
+    if (typeof current !== "string")
+        return null;
+    const pattern = new RegExp(`("version"\\s*:\\s*")${current.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(")`);
+    return pattern.test(text) ? text.replace(pattern, `$1${version}$2`) : null;
+}
+/** `VERSION = "x"` of a gem's version.rb. */
+export function bumpRubyVersion(text, version) {
+    const pattern = /^(\s*VERSION\s*=\s*["'])[^"']*(["'])/m;
+    return pattern.test(text) ? text.replace(pattern, `$1${version}$2`) : null;
+}
+/** The gem's own entry in Gemfile.lock: the spec of the `PATH` source that is the repository itself. */
+export function bumpGemfileLock(text, version) {
+    const pattern = /(^PATH\r?\n {2}remote: \.\r?\n {2}specs:\r?\n {4}\S+ \()[^)]*(\))/m;
+    return pattern.test(text) ? text.replace(pattern, `$1${version}$2`) : null;
+}
+/** The elements of an XML document in order, without reading comments, CDATA or processing instructions as tags. */
+function* elements(xml) {
+    const token = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<!\w[^>]*>|<(\/?)([\w.:-]+)([^>]*?)(\/?)>/g;
+    const open = [];
+    for (let match = token.exec(xml); match !== null; match = token.exec(xml)) {
+        const [, closing, name, , selfClosing] = match;
+        if (name === undefined || selfClosing === "/")
+            continue;
+        if (closing === "/") {
+            const element = open.pop();
+            if (element === undefined)
+                return;
+            yield { path: [...open.map((e) => e.name), element.name], start: element.start, end: match.index };
+        }
+        else {
+            open.push({ name, start: match.index + match[0].length });
+        }
+    }
+}
+/** Sets the text of the first element whose path ends with (or, when `anchored`, is exactly) `path`. */
+function setElement(xml, path, version, anchored) {
+    for (const element of elements(xml)) {
+        const tail = anchored ? element.path : element.path.slice(-path.length);
+        if (tail.length !== path.length || tail.some((name, index) => name !== path[index]))
+            continue;
+        return xml.slice(0, element.start) + version + xml.slice(element.end);
+    }
+    return null;
+}
+/** `<version>` of the project itself in pom.xml: not the parent's, a dependency's or a plugin's. */
+export function bumpPom(text, version) {
+    return setElement(text, ["project", "version"], version, true);
+}
+/** An element named by a path such as `//Project/PropertyGroup/Version` (the form release-please takes). */
+export function bumpXml(text, xpath, version) {
+    const anchored = !xpath.startsWith("//");
+    const path = xpath.replace(/^\/+/, "").split("/");
+    return path.every((name) => /^[\w.:-]+$/.test(name)) ? setElement(text, path, version, anchored) : null;
+}
+/**
+ * release-please's generic updater: the version on a line marked `x-release-please-version`, and on
+ * every line between `x-release-please-start-version` and `x-release-please-end`.
+ */
+export function bumpMarked(text, version) {
+    let inside = false;
+    let changed = false;
+    const lines = text.split("\n").map((line) => {
+        if (line.includes("x-release-please-start-version")) {
+            inside = true;
+            return line;
+        }
+        if (line.includes("x-release-please-end")) {
+            inside = false;
+            return line;
+        }
+        if ((inside || line.includes("x-release-please-version")) && SEMVER.test(line)) {
+            changed = true;
+            return line.replace(SEMVER, version);
+        }
+        return line;
+    });
+    return changed ? lines.join("\n") : null;
+}
+/** The files that can hold the version of a release, with how each is rewritten. Paths are relative to the stack. */
+function plan(release, version) {
+    const own = [];
+    if (release.type === "python") {
+        own.push({ path: "pyproject.toml", edit: (text) => bumpPyproject(text, version) }, { path: "setup.cfg", edit: (text) => bumpSetupCfg(text, version) }, { path: "setup.py", edit: (text) => bumpSetupPy(text, version) });
+    }
+    else if (release.type === "dart") {
+        own.push({ path: "pubspec.yaml", edit: (text) => bumpPubspec(text, version) });
+    }
+    else if (release.type === "maven") {
+        own.push({ path: "pom.xml", edit: (text) => bumpPom(text, version) });
+    }
+    else if (release.type === "rust") {
+        own.push({ path: "Cargo.toml", edit: (text) => bumpCargoToml(text, version) }, {
+            path: "Cargo.lock",
+            edit: async (text, read) => {
+                const name = cargoPackageName((await read("Cargo.toml")) ?? "");
+                return name ? bumpCargoLock(text, name, version) : null;
+            },
+        });
+    }
+    else if (release.type === "php") {
+        own.push({ path: "composer.json", edit: (text) => bumpComposer(text, version) });
+    }
+    else if (release.type === "ruby") {
+        if (release.versionFile)
+            own.push({ path: release.versionFile, edit: (text) => bumpRubyVersion(text, version) });
+        own.push({ path: "Gemfile.lock", edit: (text) => bumpGemfileLock(text, version) });
+    }
+    const extra = (release.extraFiles ?? []).map((file) => typeof file === "string"
+        ? { path: file, edit: (text) => bumpMarked(text, version) }
+        : { path: file.path, edit: (text) => bumpXml(text, file.xpath, version) });
+    return [...own, ...extra];
+}
+/** Paths, relative to the stack, a release of this kind can change; for the release tool to commit. */
+export function releaseFiles(release) {
+    return [...new Set(plan(release, "0.0.0").map((file) => file.path))];
+}
+/**
+ * Writes `version` into the stack's version files under `root` (the stack's own folder).
+ * Returns the paths it changed (would change, when `write` is off); a file without a version is left as it is.
+ */
+export async function bumpVersion(root, release, version, write = true) {
+    const read = async (path) => {
+        try {
+            return await readFile(join(root, path), "utf8");
+        }
+        catch {
+            return null;
+        }
+    };
+    const changed = [];
+    for (const { path, edit } of plan(release, version)) {
+        const text = await read(path);
+        if (text === null)
+            continue;
+        const next = await edit(text, read);
+        if (next === null || next === text)
+            continue;
+        if (write)
+            await writeFile(join(root, path), next);
+        changed.push(path);
+    }
+    return changed;
+}

package/dist/stacks/index.js

@@ -1,3 +1,5 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
 import { STACK_IDS } from "../config/types.js";
 import { dartStack } from "./dart.js";
 import { dotnetStack } from "./dotnet.js";
@@ -34,3 +36,57 @@ export async function detectStacks(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;
 }
+/** Folders that hold a project's by-products or samples rather than a project of the repository. */
+const NOT_A_PROJECT = new Set([
+    "node_modules",
+    "vendor",
+    "dist",
+    "build",
+    "target",
+    "out",
+    "bin",
+    "obj",
+    "coverage",
+    "example",
+    "examples",
+    "test",
+    "tests",
+    "fixtures",
+    "doc",
+    "docs",
+]);
+/**
+ * The stacks of a repository and where they are: at the root or, when the root holds no project
+ * (a monorepo such as frontend/ and backend/), in its immediate folders.
+ */
+export async function detectStackLayout(root) {
+    const atRoot = await detectStacks(root);
+    const rooted = { stacks: atRoot, directories: {}, skipped: [] };
+    // loose scripts at the root do not make it a project: a monorepo often keeps some beside its folders
+    if (atRoot.some((id) => id !== "script"))
+        return rooted;
+    const directories = {};
+    const skipped = [];
+    const folders = readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && !NOT_A_PROJECT.has(entry.name))
+        .map((entry) => entry.name)
+        .sort();
+    for (const folder of folders) {
+        for (const id of await detectStacks(join(root, folder))) {
+            if (directories[id] === undefined)
+                directories[id] = folder;
+            else
+                skipped.push({ stack: id, directory: folder });
+        }
+    }
+    let stacks = STACK_IDS.filter((id) => directories[id] !== undefined);
+    // nothing but scripts in the folders either: the root's own answer stands
+    if (atRoot.length > 0 && stacks.every((id) => id === "script"))
+        return rooted;
+    // as at the root: a folder of scripts beside real projects is tooling, not a stack
+    if (stacks.length > 1 && directories.script !== undefined) {
+        stacks = stacks.filter((id) => id !== "script");
+        delete directories.script;
+    }
+    return { stacks, directories, skipped: skipped.filter((entry) => stacks.includes(entry.stack)) };
+}

package/dist/stacks/support.js

@@ -10,6 +10,25 @@ export function checkKeys(stack, options, keys) {
         }
     }
 }
+/**
+ * The `directory` option every stack takes: the folder of a monorepo the stack lives in.
+ * Returns it with forward slashes and no trailing slash, or undefined for the repository root.
+ */
+export function stackDirectory(stack, options) {
+    const value = options.directory;
+    if (value === undefined)
+        return undefined;
+    const key = `${CONFIG_FILE}: stack_options.${stack}.directory`;
+    if (typeof value !== "string" || value.trim() === "")
+        throw new ConfigError(`${key} must be a folder name`);
+    const directory = value.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+    if (directory === "" || directory === ".")
+        return undefined;
+    if (directory.startsWith("/") || /^[A-Za-z]:/.test(directory) || directory.split("/").includes("..")) {
+        throw new ConfigError(`${key} must be a folder inside the repository, such as backend or apps/api`);
+    }
+    return directory;
+}
 /** A list option; YAML numbers such as `[22, 24]` count as strings. */
 export function stringList(stack, options, key) {
     const value = options[key];

package/dist/templates.js

@@ -1,6 +1,18 @@
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { normalizeEol } from "./sync/hash.js";
 /** Reads a bundled template with LF endings; works from src/ (tests) and dist/ (package). */
 export function readTemplate(relativePath) {
     return normalizeEol(readFileSync(new URL(`../templates/${relativePath}`, import.meta.url), "utf8"));
 }
+/** File names of the reusable workflows generated CI and release files can call. */
+export const REUSABLE_WORKFLOW = /^(stack-[a-z]+|commitlint|release-please|repokeeper-check)\.yml$/;
+/** Reads one of the reusable workflows shipped with the package, with LF endings. */
+export function readWorkflow(file) {
+    return normalizeEol(readFileSync(new URL(`../.github/workflows/${file}`, import.meta.url), "utf8"));
+}
+/** Every reusable workflow shipped with the package, by file name. */
+export function listWorkflows() {
+    return readdirSync(new URL("../.github/workflows/", import.meta.url))
+        .filter((name) => REUSABLE_WORKFLOW.test(name))
+        .sort();
+}

package/dist/version.js

@@ -9,6 +9,7 @@ export const TOOL_VERSIONS = {
     semanticRelease: "25.0.9",
     semanticReleaseChangelog: "7.0.0",
     semanticReleaseGit: "11.0.1",
+    semanticReleaseExec: "7.1.0",
     semanticReleaseGitlab: "13.3.3",
     // 10.x needs conventional-changelog-writer 9, and semantic-release 25's notes generator bundles 8
     conventionalCommitsPreset: "9.3.1",
@@ -18,6 +19,8 @@ export const TOOL_VERSIONS = {
 export const REUSABLE_REPO = "vannt-dev/repokeeper";
 /** Moving tag callers pin to: the major version of this repokeeper (v0 during 0.x). */
 export const WORKFLOW_REF = `v${PACKAGE_VERSION.split(".")[0]}`;
+/** The tag of this release, for callers that pin to it instead of following the major tag. */
+export const EXACT_WORKFLOW_REF = `v${PACKAGE_VERSION}`;
 export function compareVersions(a, b) {
     const pa = a.split(".").map(Number);
     const pb = b.split(".").map(Number);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repokeeper",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Keep every repository on one maintained standard: commits, git hooks, CI, releases, dependency updates and repo settings.",
   "type": "module",
   "bin": {
@@ -8,7 +8,11 @@
   },
   "files": [
     "dist/",
-    "templates/"
+    "templates/",
+    ".github/workflows/stack-*.yml",
+    ".github/workflows/commitlint.yml",
+    ".github/workflows/release-please.yml",
+    ".github/workflows/repokeeper-check.yml"
   ],
   "engines": {
     "node": ">=22.12.0"