repokeeper 0.1.0

package/dist/stacks/node.js

@@ -0,0 +1,81 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { UsageError } from "../errors.js";
+import { checkKeys, stringList } from "./support.js";
+const NPM_PLACEHOLDER_TEST = 'echo "Error: no test specified" && exit 1';
+const OPTION_KEYS = ["versions", "os", "scripts"];
+const CI_SCRIPTS = ["typecheck", "lint", "test", "build"];
+/** NestJS projects scaffold end-to-end tests as a separate script. */
+const NEST_CI_SCRIPTS = ["typecheck", "lint", "test", "test:e2e", "build"];
+export const nodeStack = {
+    id: "node",
+    detect: (root) => existsSync(join(root, "package.json")),
+    async resolve(root, options = {}) {
+        checkKeys("node", options, OPTION_KEYS);
+        let pkg;
+        try {
+            pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+        }
+        catch (error) {
+            throw new UsageError(`package.json could not be read: ${error.message}`);
+        }
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const pm = existsSync(join(root, "pnpm-lock.yaml")) ? "pnpm" : existsSync(join(root, "yarn.lock")) ? "yarn" : "npm";
+        const staged = [];
+        if (deps["@biomejs/biome"]) {
+            staged.push({
+                name: "node:biome",
+                glob: "*.{js,jsx,ts,tsx,mjs,cjs,json,jsonc,css}",
+                run: "npx biome check --write --no-errors-on-unmatched {staged_files}",
+            });
+        }
+        else {
+            if (deps.prettier) {
+                staged.push({
+                    name: "node:prettier",
+                    glob: "*.{js,jsx,ts,tsx,mjs,cjs,json,css,scss,md,yml,yaml,html}",
+                    run: "npx prettier --write --ignore-unknown {staged_files}",
+                });
+            }
+            if (deps.eslint) {
+                staged.push({ name: "node:eslint", glob: "*.{js,jsx,ts,tsx,mjs,cjs}", run: "npx eslint --fix {staged_files}" });
+            }
+        }
+        const testScript = pkg.scripts?.test;
+        const hasTest = testScript !== undefined && testScript !== NPM_PLACEHOLDER_TEST;
+        const npmLock = existsSync(join(root, "package-lock.json")) || existsSync(join(root, "npm-shrinkwrap.json"));
+        const ciInstall = pm === "npm"
+            ? npmLock
+                ? "npm ci"
+                : "npm install"
+            : pm === "pnpm"
+                ? "pnpm install --frozen-lockfile"
+                : existsSync(join(root, ".yarnrc.yml"))
+                    ? "yarn install --immutable"
+                    : "yarn install --frozen-lockfile";
+        const scripts = stringList("node", options, "scripts") ??
+            (existsSync(join(root, "nest-cli.json")) ? NEST_CI_SCRIPTS : CI_SCRIPTS).filter((name) => name === "test" ? hasTest : pkg.scripts?.[name] !== undefined);
+        return {
+            id: "node",
+            staged,
+            test: hasTest ? `${pm} test` : null,
+            install: `${pm} install`,
+            gitignore: ["Node"],
+            dependabot: ["npm"],
+            ci: {
+                workflow: "stack-node.yml",
+                with: {
+                    "node-versions": JSON.stringify(stringList("node", options, "versions") ?? ["22", "24"]),
+                    os: JSON.stringify(stringList("node", options, "os") ?? ["ubuntu-latest"]),
+                    "package-manager": pm,
+                    "install-command": ciInstall,
+                    // setup-node can only cache npm here: pnpm and yarn come from corepack after it runs
+                    cache: pm === "npm" && npmLock ? "npm" : "",
+                    scripts: JSON.stringify(scripts),
+                },
+            },
+            release: { type: "node", version: typeof pkg.version === "string" ? pkg.version : null },
+        };
+    },
+};

package/dist/stacks/python.js

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { checkKeys, filesMatching, optionalString, readText, stringList } from "./support.js";
+const OPTION_KEYS = ["versions", "os", "test"];
+/** The `version = "…"` of the `[project]` table, if any. */
+function projectVersion(pyproject) {
+    const table = pyproject.split(/^\[/m).find((section) => section.startsWith("project]"));
+    return table ? (/^version\s*=\s*"([^"]+)"/m.exec(table)?.[1] ?? null) : null;
+}
+export const pythonStack = {
+    id: "python",
+    detect: (root) => ["pyproject.toml", "requirements.txt", "setup.cfg"].some((f) => existsSync(join(root, f))),
+    async resolve(root, options = {}) {
+        checkKeys("python", options, OPTION_KEYS);
+        const has = (path) => existsSync(join(root, path));
+        const pyproject = (await readText(root, "pyproject.toml")) ?? "";
+        const uv = has("uv.lock");
+        const mypy = has("mypy.ini") || pyproject.includes("[tool.mypy]");
+        const hasTests = has("tests") || has("test") || filesMatching(root, ".", /^test_.*\.py$/).length > 0;
+        const customTest = optionalString("python", options, "test");
+        const pytest = customTest === undefined && hasTests;
+        const tools = ["ruff", ...(mypy ? ["mypy"] : []), ...(pytest ? ["pytest"] : [])];
+        const run = uv ? "uv run " : "";
+        const projectInstall = [];
+        if (!uv) {
+            if (has("requirements.txt"))
+                projectInstall.push("python -m pip install -r requirements.txt");
+            if (has("requirements-dev.txt"))
+                projectInstall.push("python -m pip install -r requirements-dev.txt");
+            if (/^\[project\]/m.test(pyproject))
+                projectInstall.push("python -m pip install -e .");
+        }
+        const ciInstall = uv
+            ? `uv sync --frozen && uv pip install ${tools.join(" ")}`
+            : [...projectInstall, `python -m pip install ${tools.join(" ")}`].join(" && ");
+        const test = customTest ?? (pytest ? (uv ? "uv run pytest" : "python -m pytest") : null);
+        const commands = [
+            `${run}ruff format --check .`,
+            `${run}ruff check .`,
+            ...(mypy ? [`${run}mypy .`] : []),
+            ...(test ? [test] : []),
+        ];
+        const ruff = uv ? "uvx ruff" : "ruff";
+        const staged = [
+            { name: "python:ruff-format", glob: "*.py", run: `${ruff} format {staged_files}` },
+            { name: "python:ruff-check", glob: "*.py", run: `${ruff} check --fix {staged_files}` },
+        ];
+        return {
+            id: "python",
+            staged,
+            test,
+            install: uv ? "uv sync" : projectInstall.length > 0 ? projectInstall.join(" && ") : null,
+            gitignore: ["Python"],
+            dependabot: [uv ? "uv" : "pip"],
+            ci: {
+                workflow: "stack-python.yml",
+                with: {
+                    "python-versions": JSON.stringify(stringList("python", options, "versions") ?? ["3.11", "3.12", "3.13"]),
+                    os: JSON.stringify(stringList("python", options, "os") ?? ["ubuntu-latest"]),
+                    manager: uv ? "uv" : "pip",
+                    "install-command": ciInstall,
+                    commands: JSON.stringify(commands),
+                },
+            },
+            release: { type: "python", version: projectVersion(pyproject) },
+        };
+    },
+};

package/dist/stacks/script.js

@@ -0,0 +1,29 @@
+import { checkKeys, filesMatching, optionalString } from "./support.js";
+const OPTION_KEYS = ["test"];
+const scripts = (root, pattern) => filesMatching(root, ".", pattern).length + filesMatching(root, "scripts", pattern).length > 0;
+export const scriptStack = {
+    id: "script",
+    detect: (root) => scripts(root, /\.(sh|ps1)$/),
+    async resolve(root, options = {}) {
+        checkKeys("script", options, OPTION_KEYS);
+        const test = optionalString("script", options, "test") ?? null;
+        return {
+            id: "script",
+            // shfmt, ShellCheck and PSScriptAnalyzer are rarely installed locally; CI enforces them
+            staged: [],
+            test,
+            install: null,
+            gitignore: [],
+            dependabot: [],
+            ci: {
+                workflow: "stack-script.yml",
+                with: {
+                    "shell-scripts": String(scripts(root, /\.sh$/)),
+                    "powershell-scripts": String(scripts(root, /\.ps1$/)),
+                    "test-command": test ?? "",
+                },
+            },
+            release: { type: "simple", version: null },
+        };
+    },
+};

package/dist/stacks/support.js

@@ -0,0 +1,50 @@
+import { readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CONFIG_FILE } from "../config/load.js";
+import { ConfigError } from "../errors.js";
+export function checkKeys(stack, options, keys) {
+    for (const key of Object.keys(options)) {
+        if (!keys.includes(key)) {
+            throw new ConfigError(`${CONFIG_FILE}: stack_options.${stack}.${key} is not a known key (${keys.join(", ")})`);
+        }
+    }
+}
+/** A list option; YAML numbers such as `[22, 24]` count as strings. */
+export function stringList(stack, options, key) {
+    const value = options[key];
+    if (value === undefined)
+        return undefined;
+    const valid = Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === "string" || typeof v === "number");
+    if (!valid)
+        throw new ConfigError(`${CONFIG_FILE}: stack_options.${stack}.${key} must be a non-empty list of strings`);
+    return value.map(String);
+}
+export function optionalString(stack, options, key) {
+    const value = options[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new ConfigError(`${CONFIG_FILE}: stack_options.${stack}.${key} must be a non-empty string`);
+    }
+    return value;
+}
+/** Names of the entries of `dir` (relative to root) matching `pattern`, sorted; empty when `dir` is missing. */
+export function filesMatching(root, dir, pattern) {
+    try {
+        return readdirSync(join(root, dir))
+            .filter((name) => pattern.test(name))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function readText(root, file) {
+    try {
+        return await readFile(join(root, file), "utf8");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/stacks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sync/apply.js

@@ -0,0 +1,82 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { outputId, YAML_HEADER } from "../model.js";
+import { removeBlock, upsertBlock } from "./block.js";
+import { hashText } from "./hash.js";
+import { deleteAtPath, formatJson, setAtPath } from "./json.js";
+import { targetOf, writeLock } from "./lock.js";
+import { desiredText } from "./state.js";
+import { deleteYamlKey, setYamlKey } from "./yaml.js";
+async function readOrNull(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function put(path, text) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, text);
+}
+async function write(root, output) {
+    const path = join(root, output.path);
+    if (output.kind === "file" || output.kind === "seed")
+        return put(path, output.content);
+    const existing = await readOrNull(path);
+    if (output.kind === "block")
+        return put(path, upsertBlock(existing, output.id, output.body, output.comment));
+    if (output.kind === "yaml") {
+        return put(path, setYamlKey(existing, output.path, output.keyPath, output.value, { header: YAML_HEADER, order: output.order }));
+    }
+    const data = existing ? JSON.parse(existing) : {};
+    setAtPath(data, output.keyPath, output.value);
+    return put(path, formatJson(data, existing));
+}
+async function remove(root, target) {
+    const path = join(root, target.path);
+    if (target.kind === "seed")
+        return;
+    if (target.kind === "file")
+        return rm(path, { force: true });
+    const existing = await readOrNull(path);
+    if (existing === null)
+        return;
+    if (target.kind === "block")
+        return put(path, removeBlock(existing, target.id, target.comment));
+    if (target.kind === "yaml") {
+        const next = deleteYamlKey(existing, target.path, target.keyPath);
+        return next === null ? rm(path, { force: true }) : put(path, next);
+    }
+    const data = JSON.parse(existing);
+    deleteAtPath(data, target.keyPath);
+    return put(path, formatJson(data, existing));
+}
+export async function applySync(root, result, previous, standard) {
+    const previousEntries = new Map((previous?.entries ?? []).map((e) => [e.id, e]));
+    const entries = [];
+    for (const { output, action } of result.decisions) {
+        const id = outputId(output);
+        if (action === "create" || action === "write" || action === "adopt")
+            await write(root, output);
+        if (action === "conflict" && output.kind === "file")
+            await put(join(root, `${output.path}.repokeeper-new`), output.content);
+        if (action === "conflict") {
+            const kept = previousEntries.get(id);
+            if (kept)
+                entries.push(kept);
+        }
+        else if (action !== "unmanaged") {
+            entries.push({ id, module: output.module, hash: hashText(desiredText(output)), target: targetOf(output) });
+        }
+    }
+    for (const removal of result.removals) {
+        if (removal.action === "delete")
+            await remove(root, removal.entry.target);
+    }
+    const lock = { lockVersion: 1, standard, entries };
+    await writeLock(root, lock);
+    return lock;
+}

package/dist/sync/block.js

@@ -0,0 +1,51 @@
+import { normalizeEol } from "./hash.js";
+function comment(style, text) {
+    return style === "hash" ? `# ${text}` : `<!-- ${text} -->`;
+}
+export function startMarker(id, style) {
+    return comment(style, `repokeeper:start ${id}`);
+}
+export function endMarker(id, style) {
+    return comment(style, `repokeeper:end ${id}`);
+}
+function eolOf(text) {
+    return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function locate(lines, id, style) {
+    const start = lines.indexOf(startMarker(id, style));
+    if (start < 0)
+        return null;
+    const end = lines.indexOf(endMarker(id, style), start + 1);
+    return end < 0 ? null : [start, end];
+}
+export function readBlock(text, id, style) {
+    const lines = normalizeEol(text).split("\n");
+    const range = locate(lines, id, style);
+    return range ? lines.slice(range[0] + 1, range[1]).join("\n") : null;
+}
+export function upsertBlock(text, id, body, style) {
+    const eol = text === null ? "\n" : eolOf(text);
+    const blockLines = [startMarker(id, style), ...normalizeEol(body).split("\n"), endMarker(id, style)];
+    if (text === null || text.trim() === "")
+        return blockLines.join(eol) + eol;
+    const lines = text.split(eol);
+    const range = locate(lines, id, style);
+    if (range) {
+        lines.splice(range[0], range[1] - range[0] + 1, ...blockLines);
+        return lines.join(eol);
+    }
+    const base = text.endsWith(eol) ? text : text + eol;
+    return base + eol + blockLines.join(eol) + eol;
+}
+export function removeBlock(text, id, style) {
+    const eol = eolOf(text);
+    const lines = text.split(eol);
+    const range = locate(lines, id, style);
+    if (!range)
+        return text;
+    let [start] = range;
+    if (start > 0 && lines[start - 1] === "")
+        start -= 1;
+    lines.splice(start, range[1] - start + 1);
+    return lines.join(eol);
+}

package/dist/sync/decide.js

@@ -0,0 +1,21 @@
+import { hashText } from "./hash.js";
+import { desiredText } from "./state.js";
+/** The update decision table from the spec, section 7. */
+export function decide(output, currentText, entry, adopt) {
+    if (currentText === null)
+        return "create";
+    const current = hashText(currentText);
+    if (current === hashText(desiredText(output)))
+        return "unchanged";
+    if (entry)
+        return current === entry.hash ? "write" : "conflict";
+    return adopt ? "adopt" : "unmanaged";
+}
+/** For a lock entry the standard no longer produces. */
+export function decideRemoval(entry, currentText) {
+    if (entry.target.kind === "seed")
+        return "gone"; // other tools own a seed once it exists
+    if (currentText === null)
+        return "gone";
+    return hashText(currentText) === entry.hash ? "delete" : "orphan-edited";
+}

package/dist/sync/hash.js

@@ -0,0 +1,8 @@
+import { createHash } from "node:crypto";
+export function normalizeEol(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+/** Hash of the LF-normalised text, so a checkout that converts to CRLF still matches. */
+export function hashText(text) {
+    return createHash("sha256").update(normalizeEol(text)).digest("hex");
+}

package/dist/sync/json.js

@@ -0,0 +1,31 @@
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export function getAtPath(obj, path) {
+    let current = obj;
+    for (const key of path) {
+        if (!isObject(current))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+export function setAtPath(obj, path, value) {
+    let current = obj;
+    for (const key of path.slice(0, -1)) {
+        const next = current[key];
+        if (!isObject(next))
+            current[key] = {};
+        current = current[key];
+    }
+    current[path[path.length - 1]] = value;
+}
+export function deleteAtPath(obj, path) {
+    const parent = getAtPath(obj, path.slice(0, -1));
+    if (isObject(parent))
+        delete parent[path[path.length - 1]];
+}
+/** Serialises with the original file's indentation, line ending and final newline. */
+export function formatJson(value, original) {
+    const indent = original ? (/^([ \t]+)"/m.exec(original)?.[1] ?? 2) : 2;
+    const eol = original?.includes("\r\n") ? "\r\n" : "\n";
+    return JSON.stringify(value, null, indent).replace(/\n/g, eol) + eol;
+}

package/dist/sync/lock.js

@@ -0,0 +1,40 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { LockError } from "../errors.js";
+export const LOCK_FILE = ".repokeeper/lock.json";
+export function targetOf(output) {
+    if (output.kind === "file")
+        return { kind: "file", path: output.path };
+    if (output.kind === "seed")
+        return { kind: "seed", path: output.path };
+    if (output.kind === "block")
+        return { kind: "block", path: output.path, id: output.id, comment: output.comment };
+    if (output.kind === "yaml")
+        return { kind: "yaml", path: output.path, keyPath: output.keyPath };
+    return { kind: "json", path: output.path, keyPath: output.keyPath };
+}
+export async function readLock(root) {
+    let text;
+    try {
+        text = await readFile(join(root, LOCK_FILE), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    try {
+        const data = JSON.parse(text);
+        if (data.lockVersion !== 1 || !Array.isArray(data.entries))
+            throw new Error("unexpected format");
+        return data;
+    }
+    catch (error) {
+        throw new LockError(`${LOCK_FILE} is unreadable (${error.message}); run \`repokeeper init --relock\``);
+    }
+}
+export async function writeLock(root, lock) {
+    const path = join(root, LOCK_FILE);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(lock, null, 2)}\n`);
+}

package/dist/sync/state.js

@@ -0,0 +1,50 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { UsageError } from "../errors.js";
+import { readBlock } from "./block.js";
+import { getAtPath } from "./json.js";
+import { readYamlKey } from "./yaml.js";
+/** The text repokeeper compares and hashes for an output. */
+export function desiredText(output) {
+    if (output.kind === "file")
+        return output.content;
+    // a seed only has to exist, so present content always compares equal
+    if (output.kind === "seed")
+        return "";
+    if (output.kind === "block")
+        return output.body;
+    return JSON.stringify(output.value);
+}
+async function readText(root, path) {
+    try {
+        return await readFile(join(root, path), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+/** The same comparable text read from disk, or null when absent. */
+export async function readCurrent(root, target) {
+    const text = await readText(root, target.path);
+    if (text === null)
+        return null;
+    if (target.kind === "file")
+        return text;
+    if (target.kind === "seed")
+        return "";
+    if (target.kind === "block")
+        return readBlock(text, target.id, target.comment);
+    if (target.kind === "yaml")
+        return readYamlKey(text, target.keyPath, target.path);
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch (error) {
+        throw new UsageError(`${target.path} is not valid JSON: ${error.message}`);
+    }
+    const value = getAtPath(data, target.keyPath);
+    return value === undefined ? null : JSON.stringify(value);
+}

package/dist/sync/sync.js

@@ -0,0 +1,32 @@
+import { outputId } from "../model.js";
+import { decide, decideRemoval } from "./decide.js";
+import { targetOf } from "./lock.js";
+import { readCurrent } from "./state.js";
+export async function computeSync(root, outputs, lock, options) {
+    const entries = new Map((lock?.entries ?? []).map((e) => [e.id, e]));
+    const decisions = [];
+    for (const output of outputs) {
+        const adopt = options.adopt === "all" || options.adopt.has(output.path);
+        let action = decide(output, await readCurrent(root, targetOf(output)), entries.get(outputId(output)), adopt);
+        if (action === "conflict" && options.accept.has(output.path))
+            action = "write";
+        decisions.push({ output, action });
+    }
+    const wanted = new Set(outputs.map(outputId));
+    const removals = [];
+    for (const entry of entries.values()) {
+        if (!wanted.has(entry.id))
+            removals.push({ entry, action: decideRemoval(entry, await readCurrent(root, entry.target)) });
+    }
+    return { decisions, removals };
+}
+const WRITES = ["create", "write", "adopt"];
+/** Existing paths a sync would change; guarded against uncommitted edits. */
+export function pathsToWrite(result) {
+    return [
+        ...new Set([
+            ...result.decisions.filter((d) => WRITES.includes(d.action)).map((d) => d.output.path),
+            ...result.removals.filter((r) => r.action === "delete").map((r) => r.entry.target.path),
+        ]),
+    ];
+}

package/dist/sync/yaml.js

@@ -0,0 +1,49 @@
+import { Document, isMap, isScalar, parseDocument } from "yaml";
+import { UsageError } from "../errors.js";
+import { getAtPath } from "./json.js";
+function parse(text, file) {
+    const doc = parseDocument(text);
+    const error = doc.errors[0];
+    if (error)
+        throw new UsageError(`${file} is not valid YAML: ${error.message.split("\n")[0]}`);
+    return doc;
+}
+function render(doc, original) {
+    const text = doc.toString({ lineWidth: 0, nullStr: "", flowCollectionPadding: false });
+    return original?.includes("\r\n") ? text.replace(/\r?\n/g, "\r\n") : text;
+}
+/** JSON text of the value at `keyPath`, or null when the key is absent. */
+export function readYamlKey(text, keyPath, file) {
+    const value = getAtPath(parse(text, file).toJS() ?? {}, keyPath);
+    return value === undefined ? null : JSON.stringify(value);
+}
+export function setYamlKey(text, file, keyPath, value, options) {
+    const fresh = text === null || text.trim() === "";
+    const doc = text !== null && !fresh ? parse(text, file) : new Document({});
+    if (fresh)
+        doc.commentBefore = ` ${options.header}`;
+    doc.setIn(keyPath, doc.createNode(value));
+    const order = options.order;
+    if (order && isMap(doc.contents)) {
+        const rank = (key) => {
+            const index = order.indexOf(String(isScalar(key) ? key.value : key));
+            return index === -1 ? order.length : index;
+        };
+        doc.contents.items.sort((a, b) => rank(a.key) - rank(b.key));
+    }
+    return render(doc, text);
+}
+/** Removes the key and any parents it leaves empty; null when nothing is left. */
+export function deleteYamlKey(text, file, keyPath) {
+    const doc = parse(text, file);
+    doc.deleteIn(keyPath);
+    for (let depth = keyPath.length - 1; depth > 0; depth--) {
+        const parent = doc.getIn(keyPath.slice(0, depth));
+        if (!isMap(parent) || parent.items.length > 0)
+            break;
+        doc.deleteIn(keyPath.slice(0, depth));
+    }
+    if (!isMap(doc.contents) || doc.contents.items.length === 0)
+        return null;
+    return render(doc, text);
+}

package/dist/templates.js

@@ -0,0 +1,6 @@
+import { 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"));
+}

package/dist/version.js

@@ -0,0 +1,23 @@
+import { readFileSync } from "node:fs";
+export const PACKAGE_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+/** The standard this build of repokeeper applies. Bump it whenever generated output changes. */
+export const STANDARD_VERSION = "1.2.0";
+export const TOOL_VERSIONS = {
+    lefthook: "2.1.14",
+    commitlintCli: "21.2.3",
+    commitlintConventional: "21.2.3",
+};
+/** Repository hosting the reusable workflows that generated CI files call. */
+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]}`;
+export function compareVersions(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}