repokeeper 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Van Nguyen
+
+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.

package/README.md

@@ -0,0 +1,54 @@
+# repokeeper
+
+Keep every repository on one maintained standard: Conventional Commits, git hooks, community health
+files, editor and gitignore settings, Dependabot, CI and releases — applied once and kept in sync as
+the standard evolves.
+
+> Status: early development. Supported stacks: Node.js (including NestJS), Python, Dart and
+> Flutter, shell and PowerShell scripts, Java (Maven and Gradle) and .NET, each with CI and releases.
+> GitHub settings are on the way. See the [design](docs/superpowers/specs/2026-09-25-repokeeper-design.md).
+
+## Usage
+
+repokeeper is not on npm yet. Until the first release, build it from source and link the command:
+
+```bash
+git clone https://github.com/vannt-dev/repokeeper.git
+cd repokeeper && npm ci && npm run build && npm link
+```
+
+Then, in the repository you want to standardise (commit your work first — repokeeper refuses to
+write over uncommitted or untracked files unless you pass `--force`):
+
+```bash
+repokeeper init     # detect the stack, write .repokeeper.yml, apply the standard
+repokeeper check    # report drift; exits 1 when the repository has drifted
+repokeeper update   # move to the latest standard without overwriting your edits
+```
+
+`init` never overwrites a file you already have: it reports it as unmanaged. Pass
+`--adopt <path>` to let repokeeper manage it, or list it under `owned` in `.repokeeper.yml` to keep it
+yours. Every write command accepts `--dry-run`.
+
+Requires Node.js 22.12 or newer.
+
+## CI and releases
+
+`ci.yml` and `release.yml` call reusable workflows from this repository (`stack-node.yml`,
+`commitlint.yml`, `release-please.yml`) at the moving major tag, so fixes reach every repository
+without a pull request. repokeeper owns the `name`, `on` and `permissions` keys and the jobs it
+adds; jobs you add yourself are left alone.
+
+`release.yml` runs [release-please](https://github.com/googleapis/release-please): it keeps a release
+pull request open, and merging it tags the release and updates `CHANGELOG.md`. Two settings make this
+work:
+
+- In the repository settings, under Actions → General, allow GitHub Actions to create and approve
+  pull requests.
+- Optionally add a `RELEASE_PLEASE_TOKEN` secret (a fine-grained token with contents, pull requests
+  and issues write access). Without it the release pull request is opened with `GITHUB_TOKEN`, and
+  GitHub does not run CI on pull requests opened that way.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { checkCommand } from "./commands/check.js";
+import { initCommand } from "./commands/init.js";
+import { updateCommand } from "./commands/update.js";
+import { STACK_IDS } from "./config/types.js";
+import { RepokeeperError, UsageError } from "./errors.js";
+import { PACKAGE_VERSION } from "./version.js";
+export const USAGE = [
+    "usage: repokeeper <command> [options]",
+    "",
+    "commands:",
+    "  init    detect stacks, write .repokeeper.yml and apply the standard",
+    "  check   report drift from the standard without writing (exit 1 on drift)",
+    "  update  move to the standard of this repokeeper version and resync",
+    "",
+    "options:",
+    "  --dry-run        show what would change without writing",
+    "  --force          write even when target files have uncommitted changes",
+    "  --adopt <path>   let repokeeper manage an existing file (repeatable); --adopt-all for every file",
+    "  --accept <path>  take repokeeper's version of a locally edited file (update, repeatable)",
+    "  --stack <id>     stack to use instead of detection (init, repeatable)",
+    "  --relock         rebuild .repokeeper/lock.json from the current files (init)",
+    "  --json           machine-readable output (check)",
+    "  -v, --version    print the version",
+].join("\n");
+const toPosix = (path) => path.replace(/\\/g, "/").replace(/^\.\//, "");
+export async function run(argv, io) {
+    try {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            strict: true,
+            options: {
+                "dry-run": { type: "boolean", default: false },
+                force: { type: "boolean", default: false },
+                adopt: { type: "string", multiple: true, default: [] },
+                "adopt-all": { type: "boolean", default: false },
+                accept: { type: "string", multiple: true, default: [] },
+                stack: { type: "string", multiple: true, default: [] },
+                relock: { type: "boolean", default: false },
+                json: { type: "boolean", default: false },
+                version: { type: "boolean", short: "v", default: false },
+                help: { type: "boolean", short: "h", default: false },
+            },
+        }).valueOf();
+        if (values.version) {
+            io.out(PACKAGE_VERSION);
+            return 0;
+        }
+        const [command] = positionals;
+        if (values.help || command === undefined) {
+            io.out(USAGE);
+            return command === undefined && !values.help ? 2 : 0;
+        }
+        const stacks = values.stack;
+        for (const stack of stacks) {
+            if (!STACK_IDS.includes(stack)) {
+                throw new UsageError(`unknown stack ${stack}; expected one of ${STACK_IDS.join(", ")}`);
+            }
+        }
+        const options = {
+            dryRun: values["dry-run"],
+            force: values.force,
+            adopt: values.adopt.map(toPosix),
+            adoptAll: values["adopt-all"],
+            accept: values.accept.map(toPosix),
+            stacks: stacks,
+            relock: values.relock,
+            json: values.json,
+        };
+        if (command === "init")
+            return await initCommand(io.cwd, options, io);
+        if (command === "check")
+            return await checkCommand(io.cwd, options, io);
+        if (command === "update")
+            return await updateCommand(io.cwd, options, io);
+        throw new UsageError(`unknown command: ${command}`);
+    }
+    catch (error) {
+        if (error instanceof RepokeeperError) {
+            io.err(`repokeeper: ${error.message}`);
+            if (error instanceof UsageError)
+                io.err(USAGE);
+            return error.exitCode;
+        }
+        if (error instanceof TypeError && "code" in error && String(error.code).startsWith("ERR_PARSE_ARGS")) {
+            io.err(`repokeeper: ${error.message}`);
+            io.err(USAGE);
+            return 2;
+        }
+        throw error;
+    }
+}
+const invokedPath = process.argv[1];
+if (invokedPath !== undefined && realpathSync(invokedPath) === fileURLToPath(import.meta.url)) {
+    run(process.argv.slice(2), {
+        cwd: process.cwd(),
+        out: (line) => process.stdout.write(`${line}\n`),
+        err: (line) => process.stderr.write(`${line}\n`),
+    }).then((code) => {
+        process.exitCode = code;
+    });
+}

package/dist/commands/check.js

@@ -0,0 +1,45 @@
+import { loadConfig } from "../config/load.js";
+import { UsageError } from "../errors.js";
+import { outputId } from "../model.js";
+import { planOutputs } from "../plan.js";
+import { readLock } from "../sync/lock.js";
+import { computeSync } from "../sync/sync.js";
+import { compareVersions, STANDARD_VERSION } from "../version.js";
+import { buildContext } from "./context.js";
+import { hasDrift, printResult } from "./report.js";
+export function assertSupportedStandard(standard) {
+    if (compareVersions(standard, STANDARD_VERSION) > 0) {
+        throw new UsageError(`this repository uses standard ${standard}, newer than ${STANDARD_VERSION}; upgrade repokeeper`);
+    }
+}
+export async function checkCommand(root, options, io) {
+    const config = await loadConfig(root);
+    assertSupportedStandard(config.standard);
+    const lock = await readLock(root);
+    if (!lock) {
+        io.err("repokeeper: .repokeeper/lock.json is missing; run `repokeeper init --relock`");
+        return 1;
+    }
+    const ctx = await buildContext(root, config);
+    const result = await computeSync(root, planOutputs(ctx), lock, { adopt: new Set(), accept: new Set() });
+    const behind = config.standard !== STANDARD_VERSION || lock.standard !== STANDARD_VERSION;
+    const clean = !hasDrift(result) && !behind;
+    if (options.json) {
+        io.out(JSON.stringify({
+            clean,
+            standard: { config: config.standard, lock: lock.standard, current: STANDARD_VERSION },
+            items: [
+                ...result.decisions
+                    .filter((d) => d.action !== "unchanged")
+                    .map((d) => ({ id: outputId(d.output), path: d.output.path, action: d.action })),
+                ...result.removals.map((r) => ({ id: r.entry.id, path: r.entry.target.path, action: r.action })),
+            ],
+        }));
+        return clean ? 0 : 1;
+    }
+    printResult(io, result);
+    if (behind)
+        io.out(`standard   ${config.standard} applied, ${STANDARD_VERSION} available (run \`repokeeper update\`)`);
+    io.out(clean ? "repository matches the standard" : "repository has drifted from the standard");
+    return clean ? 0 : 1;
+}

package/dist/commands/context.js

@@ -0,0 +1,7 @@
+import { repoInfo } from "../git.js";
+import { githubPlatform } from "../platforms/github.js";
+import { getStackPack } from "../stacks/index.js";
+export async function buildContext(root, config, repo) {
+    const stacks = await Promise.all(config.stacks.map((id) => getStackPack(id).resolve(root, config.stack_options[id] ?? {})));
+    return { config, stacks, platform: githubPlatform, repo: repo ?? (await repoInfo(root)) };
+}

package/dist/commands/init.js

@@ -0,0 +1,89 @@
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CONFIG_FILE, loadConfig, renderConfig } from "../config/load.js";
+import { defaultConfig } from "../config/types.js";
+import { UsageError } from "../errors.js";
+import { dirtyPaths, gitUserName, repoInfo } from "../git.js";
+import { outputId } from "../model.js";
+import { planOutputs } from "../plan.js";
+import { detectStacks } from "../stacks/index.js";
+import { applySync } from "../sync/apply.js";
+import { hashText } from "../sync/hash.js";
+import { targetOf, writeLock } from "../sync/lock.js";
+import { readCurrent } from "../sync/state.js";
+import { computeSync, pathsToWrite } from "../sync/sync.js";
+import { STANDARD_VERSION } from "../version.js";
+import { buildContext } from "./context.js";
+import { printResult } from "./report.js";
+export async function guardUncommitted(root, result, force) {
+    if (force)
+        return;
+    const dirty = await dirtyPaths(root, pathsToWrite(result));
+    if (dirty.length === 0)
+        return;
+    const names = dirty.map((d) => (d.untracked ? `${d.path} (untracked)` : d.path)).join(", ");
+    const hint = dirty.some((d) => d.untracked)
+        ? "; untracked files are protected too, so commit them first (git add -A && git commit), or pass --force"
+        : "; commit or stash them, or pass --force";
+    throw new UsageError(`uncommitted changes in ${names}${hint}`);
+}
+export async function initCommand(root, options, io) {
+    if (options.relock)
+        return relock(root, options, io);
+    if (existsSync(join(root, CONFIG_FILE))) {
+        throw new UsageError(`${CONFIG_FILE} already exists; run \`repokeeper update\` or \`repokeeper check\``);
+    }
+    const stacks = options.stacks.length > 0 ? options.stacks : await detectStacks(root);
+    if (stacks.length === 0)
+        throw new UsageError("no supported stack detected; pass --stack node");
+    const repo = await repoInfo(root);
+    const holder = (await gitUserName(root)) ?? repo.owner ?? "the project authors";
+    const config = defaultConfig({
+        stacks,
+        standard: STANDARD_VERSION,
+        copyright: `${new Date().getFullYear()} ${holder}`,
+        contact: repo.owner ? `https://github.com/${repo.owner}` : "the repository maintainers",
+        codeowners: repo.owner ? [`@${repo.owner}`] : [],
+    });
+    const ctx = await buildContext(root, config, repo);
+    const adopt = options.adoptAll ? "all" : new Set(options.adopt);
+    const result = await computeSync(root, planOutputs(ctx), null, { adopt, accept: new Set() });
+    if (!options.dryRun)
+        await guardUncommitted(root, result, options.force);
+    printResult(io, result);
+    if (options.dryRun) {
+        io.out("dry run: nothing written");
+        return 0;
+    }
+    await writeFile(join(root, CONFIG_FILE), renderConfig(config));
+    await applySync(root, result, null, STANDARD_VERSION);
+    io.out(`applied standard ${STANDARD_VERSION}; wrote ${CONFIG_FILE}`);
+    io.out(`next: install dependencies (this installs the git hooks), then commit with "chore(repokeeper): apply standard ${STANDARD_VERSION}"`);
+    return 0;
+}
+/** Records the current content of every planned output as repokeeper's own, rebuilding a lost or corrupt lock. */
+async function relock(root, options, io) {
+    const config = await loadConfig(root);
+    const ctx = await buildContext(root, config);
+    const lock = { lockVersion: 1, standard: config.standard, entries: [] };
+    for (const output of planOutputs(ctx)) {
+        const current = await readCurrent(root, targetOf(output));
+        if (current === null)
+            continue;
+        lock.entries.push({
+            id: outputId(output),
+            module: output.module,
+            hash: hashText(current),
+            target: targetOf(output),
+        });
+        io.out(`recorded   ${output.path}`);
+    }
+    if (options.dryRun) {
+        io.out("dry run: nothing written");
+        return 0;
+    }
+    await writeLock(root, lock);
+    io.out(`rebuilt .repokeeper/lock.json with ${lock.entries.length} entries`);
+    return 0;
+}

package/dist/commands/report.js

@@ -0,0 +1,27 @@
+import { describeOutput } from "../model.js";
+const HINTS = {
+    conflict: (p) => `edited locally; take repokeeper's version with --accept ${p}, or add it to owned in .repokeeper.yml`,
+    unmanaged: (p) => `exists and is not managed; let repokeeper manage it with --adopt ${p}, or add it to owned`,
+};
+export function printResult(io, result) {
+    let unchanged = 0;
+    for (const { output, action } of result.decisions) {
+        if (action === "unchanged") {
+            unchanged++;
+            continue;
+        }
+        const hint = HINTS[action]?.(output.path);
+        io.out(`${action.padEnd(10)} ${describeOutput(output)}${hint ? ` (${hint})` : ""}`);
+    }
+    for (const { entry, action } of result.removals) {
+        if (action === "gone")
+            continue;
+        const label = action === "delete" ? "delete" : "kept";
+        const note = action === "delete" ? "" : " (no longer generated, but edited locally; left in place)";
+        io.out(`${label.padEnd(10)} ${entry.target.path}${note}`);
+    }
+    io.out(`${unchanged} output(s) already match the standard`);
+}
+export function hasDrift(result) {
+    return result.decisions.some((d) => d.action !== "unchanged") || result.removals.length > 0;
+}

package/dist/commands/update.js

@@ -0,0 +1,42 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CONFIG_FILE, loadConfig, setStandard } from "../config/load.js";
+import { UsageError } from "../errors.js";
+import { planOutputs } from "../plan.js";
+import { applySync } from "../sync/apply.js";
+import { readLock } from "../sync/lock.js";
+import { computeSync } from "../sync/sync.js";
+import { STANDARD_VERSION } from "../version.js";
+import { assertSupportedStandard } from "./check.js";
+import { buildContext } from "./context.js";
+import { guardUncommitted } from "./init.js";
+import { printResult } from "./report.js";
+export async function updateCommand(root, options, io) {
+    const config = await loadConfig(root);
+    assertSupportedStandard(config.standard);
+    const lock = await readLock(root);
+    if (!lock)
+        throw new UsageError(".repokeeper/lock.json is missing; run `repokeeper init --relock` first");
+    const ctx = await buildContext(root, { ...config, standard: STANDARD_VERSION });
+    const adopt = options.adoptAll ? "all" : new Set(options.adopt);
+    const result = await computeSync(root, planOutputs(ctx), lock, { adopt, accept: new Set(options.accept) });
+    if (!options.dryRun)
+        await guardUncommitted(root, result, options.force);
+    printResult(io, result);
+    if (options.dryRun) {
+        io.out("dry run: nothing written");
+        return 0;
+    }
+    await applySync(root, result, lock, STANDARD_VERSION);
+    if (config.standard !== STANDARD_VERSION) {
+        const path = join(root, CONFIG_FILE);
+        await writeFile(path, setStandard(await readFile(path, "utf8"), STANDARD_VERSION));
+    }
+    const conflicts = result.decisions.filter((d) => d.action === "conflict");
+    if (conflicts.length > 0) {
+        io.out(`${conflicts.length} file(s) kept because they were edited locally; new versions are beside them as *.repokeeper-new`);
+        return 1;
+    }
+    io.out(`repository is on standard ${STANDARD_VERSION}; commit with "chore(repokeeper): update standard to ${STANDARD_VERSION}"`);
+    return 0;
+}

package/dist/config/load.js

@@ -0,0 +1,99 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Ajv } from "ajv";
+import { isNode, LineCounter, parseDocument, stringify } from "yaml";
+import { ConfigError } from "../errors.js";
+import { configSchema } from "./schema.js";
+export const CONFIG_FILE = ".repokeeper.yml";
+const validate = new Ajv({ allErrors: false }).compile(configSchema);
+export async function loadConfig(root) {
+    let text;
+    try {
+        text = await readFile(join(root, CONFIG_FILE), "utf8");
+    }
+    catch {
+        throw new ConfigError(`${CONFIG_FILE} not found; run \`repokeeper init\` first`);
+    }
+    return parseConfig(text);
+}
+export function parseConfig(text) {
+    const lineCounter = new LineCounter();
+    const doc = parseDocument(text, { lineCounter });
+    const syntax = doc.errors[0];
+    if (syntax) {
+        const line = syntax.linePos?.[0]?.line ?? 1;
+        throw new ConfigError(`${CONFIG_FILE}:${line}: ${syntax.message.split("\n")[0]}`);
+    }
+    const data = doc.toJS() ?? {};
+    if (!validate(data)) {
+        const error = validate.errors?.[0];
+        const path = pathOf(error);
+        throw new ConfigError(`${CONFIG_FILE}:${lineOf(doc, lineCounter, path)}: ${describe(error, path)}`);
+    }
+    return withDefaults(data);
+}
+export function renderConfig(config) {
+    return `# repokeeper configuration: https://github.com/vannt-dev/repokeeper\n${stringify(config)}`;
+}
+/** Rewrites `standard:` in place, keeping every comment and the rest of the layout. */
+export function setStandard(text, version) {
+    const doc = parseDocument(text);
+    doc.set("standard", version);
+    return doc.toString();
+}
+function withDefaults(data) {
+    const modules = (data.modules ?? {});
+    if (modules.health === undefined) {
+        throw new ConfigError(`${CONFIG_FILE}: modules.health is required; set it to false to leave community health files alone`);
+    }
+    const config = {
+        schema: data.schema,
+        standard: data.standard,
+        platform: data.platform,
+        stacks: data.stacks,
+        modules: {
+            editorconfig: modules.editorconfig ?? true,
+            commits: modules.commits ?? true,
+            hooks: modules.hooks ?? true,
+            ci: modules.ci ?? true,
+            release: modules.release ?? true,
+            deps: modules.deps ?? true,
+            gitignore: modules.gitignore ?? true,
+            health: modules.health,
+        },
+        owned: data.owned ?? [],
+        stack_options: data.stack_options ?? {},
+    };
+    if (data.github !== undefined)
+        config.github = data.github;
+    return config;
+}
+function pathOf(error) {
+    const segments = error.instancePath
+        .split("/")
+        .slice(1)
+        .map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"))
+        .map((s) => (/^\d+$/.test(s) ? Number(s) : s));
+    if (error.keyword === "additionalProperties") {
+        segments.push(error.params.additionalProperty);
+    }
+    return segments;
+}
+function describe(error, path) {
+    const name = path.length > 0 ? path.join(".") : "(root)";
+    if (error.keyword === "additionalProperties")
+        return `${name} is not a known key`;
+    if (error.keyword === "enum") {
+        const allowed = error.params.allowedValues;
+        return `${name} must be one of: ${allowed.join(", ")}`;
+    }
+    return `${name} ${error.message ?? "is invalid"}`;
+}
+function lineOf(doc, lineCounter, path) {
+    for (let length = path.length; length > 0; length--) {
+        const node = doc.getIn(path.slice(0, length), true);
+        if (isNode(node) && node.range)
+            return lineCounter.linePos(node.range[0]).line;
+    }
+    return 1;
+}

package/dist/config/schema.js

@@ -0,0 +1,45 @@
+import { STACK_IDS } from "./types.js";
+const flag = { type: "boolean" };
+export const configSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["schema", "standard", "platform", "stacks"],
+    properties: {
+        schema: { const: 1 },
+        standard: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+$" },
+        platform: { enum: ["github"] },
+        stacks: { type: "array", minItems: 1, uniqueItems: true, items: { enum: [...STACK_IDS] } },
+        modules: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                editorconfig: flag,
+                commits: flag,
+                hooks: flag,
+                ci: flag,
+                release: flag,
+                deps: flag,
+                gitignore: flag,
+                health: {
+                    anyOf: [
+                        { const: false },
+                        {
+                            type: "object",
+                            additionalProperties: false,
+                            required: ["license", "copyright", "contact", "codeowners"],
+                            properties: {
+                                license: { anyOf: [{ const: false }, { type: "string", minLength: 1 }] },
+                                copyright: { type: "string", minLength: 1 },
+                                contact: { type: "string", minLength: 1 },
+                                codeowners: { type: "array", items: { type: "string", pattern: "^@" } },
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        owned: { type: "array", items: { type: "string", minLength: 1 } },
+        stack_options: { type: "object" },
+        github: { type: "object" },
+    },
+};

package/dist/config/types.js

@@ -0,0 +1,21 @@
+export const STACK_IDS = ["node", "python", "dart", "script", "java", "dotnet"];
+export function defaultConfig(input) {
+    return {
+        schema: 1,
+        standard: input.standard,
+        platform: "github",
+        stacks: input.stacks,
+        modules: {
+            editorconfig: true,
+            commits: true,
+            hooks: true,
+            ci: true,
+            release: true,
+            deps: true,
+            gitignore: true,
+            health: { license: "MIT", copyright: input.copyright, contact: input.contact, codeowners: input.codeowners },
+        },
+        owned: [],
+        stack_options: {},
+    };
+}

package/dist/errors.js

@@ -0,0 +1,26 @@
+export class RepokeeperError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = new.target.name;
+    }
+}
+/** `.repokeeper.yml` is missing or invalid. */
+export class ConfigError extends RepokeeperError {
+    constructor(message) {
+        super(message, 2);
+    }
+}
+/** The command cannot run as requested. */
+export class UsageError extends RepokeeperError {
+    constructor(message) {
+        super(message, 2);
+    }
+}
+/** `.repokeeper/lock.json` is unreadable; the repository state is unknown, which counts as drift. */
+export class LockError extends RepokeeperError {
+    constructor(message) {
+        super(message, 1);
+    }
+}

package/dist/git.js

@@ -0,0 +1,44 @@
+import { execFile } from "node:child_process";
+import { basename } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function git(root, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd: root, encoding: "utf8" });
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
+export async function isGitRepo(root) {
+    return (await git(root, ["rev-parse", "--is-inside-work-tree"]))?.trim() === "true";
+}
+export function parseRemoteUrl(url) {
+    const match = /github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/.exec(url.trim());
+    return match ? { owner: match[1], name: match[2] } : null;
+}
+export async function repoInfo(root) {
+    const url = await git(root, ["remote", "get-url", "origin"]);
+    return (url ? parseRemoteUrl(url) : null) ?? { owner: null, name: basename(root) };
+}
+export async function gitUserName(root) {
+    return (await git(root, ["config", "user.name"]))?.trim() || null;
+}
+/** Paths among `paths` with uncommitted changes, including untracked files. Empty outside git. */
+export async function dirtyPaths(root, paths) {
+    if (paths.length === 0 || !(await isGitRepo(root)))
+        return [];
+    const out = await git(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...paths]);
+    if (!out)
+        return [];
+    const tokens = out.split("\0").filter(Boolean);
+    const dirty = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        dirty.push({ path: token.slice(3), untracked: token.startsWith("??") });
+        if (token.startsWith("R") || token.startsWith("C"))
+            i++;
+    }
+    return dirty;
+}

package/dist/model.js

@@ -0,0 +1,21 @@
+export const MANAGED_HEADER = "Managed by repokeeper (https://github.com/vannt-dev/repokeeper). Edits are reported by `repokeeper check`.";
+/** Header of YAML files repokeeper creates but owns only in part. */
+export const YAML_HEADER = `${MANAGED_HEADER} Keys and jobs you add yourself are left alone.`;
+export function outputId(output) {
+    if (output.kind === "file")
+        return `file:${output.path}`;
+    if (output.kind === "seed")
+        return `seed:${output.path}`;
+    if (output.kind === "block")
+        return `block:${output.path}#${output.id}`;
+    if (output.kind === "yaml")
+        return `yaml:${output.path}#${JSON.stringify(output.keyPath)}`;
+    return `json:${output.path}#${JSON.stringify(output.keyPath)}`;
+}
+export function describeOutput(output) {
+    if (output.kind === "file" || output.kind === "seed")
+        return output.path;
+    if (output.kind === "block")
+        return `${output.path} (block ${output.id})`;
+    return `${output.path} (${output.keyPath.join(".")})`;
+}

package/dist/modules/ci.js

@@ -0,0 +1,5 @@
+export const ciModule = {
+    id: "ci",
+    enabled: (config) => config.modules.ci,
+    outputs: (ctx) => ctx.platform.ciWorkflow(ctx),
+};