@ramon-sg/issue-flow 0.0.0-stage → 0.2.0

package/dist/commands/upgrade.js

@@ -0,0 +1,85 @@
+/**
+ * @file `issue-flow upgrade [--dry-run]`: moves the repo's flow files to the version that
+ * runs: the dev dependencies to the ones it pins, and the hooks and the config's schema to
+ * it. `@ramon-sg/agent-kit` runs it as `npx @ramon-sg/issue-flow@<version> upgrade` and then
+ * moves the flow's skills to the same tag, because the skills call this CLI.
+ */
+import { CONFIG_PATH } from "../config-base.js";
+import { checkoutRoot, locateRepo } from "../git.js";
+import { dependencyVersion, withFlowPackages } from "../package-edits.js";
+import { hookVersions, registerHooks } from "../settings-hooks.js";
+import { FLOW_REPO, ownVersions, PACKAGE, packageManager, readJson, SETTINGS_FILE, SetupError, writeJson } from "../setup-files.js";
+import { schemaUrl } from "./init.js";
+/** The start of the schema URL `init` writes, at any version. */
+const SCHEMA_PREFIX = `https://raw.githubusercontent.com/${FLOW_REPO}/`;
+/** A release version, after an optional range sign. */
+const RELEASE = /^[\^~=]?(\d+)\.(\d+)\.(\d+)$/;
+/**
+ * Whether a version is newer than another; false if either is not a release.
+ * @param version - The version, maybe with a range sign.
+ * @param than - The other.
+ * @returns True if it is newer.
+ */
+function isNewer(version, than) {
+    const [left, right] = [RELEASE.exec(version), RELEASE.exec(than)];
+    if (left === null || right === null)
+        return false;
+    for (let index = 1; index <= 3; index += 1) {
+        const diff = Number(left[index]) - Number(right[index]);
+        if (diff !== 0)
+            return diff > 0;
+    }
+    return false;
+}
+/**
+ * The newest version of the flow the repo already has, in package.json or a hook.
+ * @param root - The repo.
+ * @returns The version, or null if it has none.
+ */
+function repoVersion(root) {
+    const found = [dependencyVersion(readJson(root, "package.json"), PACKAGE), ...Object.values(hookVersions(readJson(root, SETTINGS_FILE)))];
+    return found.filter((version) => version !== null).reduce((newest, version) => (newest === null || isNewer(version, newest) ? version : newest), null);
+}
+/**
+ * Moves the repo's flow files to this version; see the file's header.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns 0.
+ * @throws SetupError outside the main checkout, if a file is broken, or if the repo is
+ * already at a newer version (a stale local copy must not move it back).
+ * @example upgrade({ cwd, dryRun: false }, out)
+ */
+export function upgrade(options, out) {
+    const located = locateRepo(options.cwd);
+    if (located === null)
+        throw new SetupError("run upgrade inside a checkout of the repo.");
+    const root = located.mainRoot;
+    if (checkoutRoot(options.cwd) !== root)
+        throw new SetupError(`run upgrade in the main checkout, ${root}, not in a worktree.`);
+    const versions = ownVersions();
+    const current = repoVersion(root);
+    if (current !== null && isNewer(current, versions.issueFlow))
+        throw new SetupError(`the repo is at issue-flow ${current}, newer than this ${versions.issueFlow}; run 'npx ${PACKAGE}@${current.replace(/^[\^~=]/, "")} upgrade' or 'npx @ramon-sg/agent-kit'.`);
+    const writes = [];
+    const lines = [];
+    const pkg = withFlowPackages(readJson(root, "package.json"), versions, true);
+    if (pkg.changes.length > 0)
+        writes.push({ path: "package.json", value: pkg.pkg });
+    lines.push(...pkg.changes.map((change) => `package.json: ${change}`));
+    const hooks = registerHooks(readJson(root, SETTINGS_FILE), versions.issueFlow);
+    if (hooks.changes.length > 0)
+        writes.push({ path: SETTINGS_FILE, value: hooks.settings });
+    lines.push(...hooks.changes.map((change) => `${SETTINGS_FILE}: ${change}`));
+    const config = readJson(root, CONFIG_PATH);
+    if (config !== null && typeof config.$schema === "string" && config.$schema.startsWith(SCHEMA_PREFIX) && config.$schema !== schemaUrl(versions.issueFlow)) {
+        writes.push({ path: CONFIG_PATH, value: { ...config, $schema: schemaUrl(versions.issueFlow) } });
+        lines.push(`${CONFIG_PATH}: $schema at v${versions.issueFlow}`);
+    }
+    out.stdout(lines.length === 0 ? `Already at issue-flow ${versions.issueFlow}.\n` : `To issue-flow ${versions.issueFlow}:\n${lines.map((line) => `  ${line}\n`).join("")}`);
+    if (options.dryRun || writes.length === 0)
+        return 0;
+    for (const write of writes)
+        writeJson(root, write.path, write.value);
+    out.stdout(`Next: run '${packageManager(root, readJson(root, "package.json"))} install', review the diff and commit it.\n`);
+    return 0;
+}

package/dist/commands/worktree.d.ts

@@ -0,0 +1,82 @@
+import type { FlowConfig } from "../config.js";
+import { type Output } from "../output.js";
+import { type StepPlace } from "../worktree-steps.js";
+/** Options of `issue-flow worktree`. */
+export interface WorktreeOptions {
+    repo: string | null;
+    config: FlowConfig;
+    cwd: string;
+    yes: boolean;
+    only: string | null;
+    path: string | null;
+    next: boolean;
+}
+/**
+ * The base branch: the config's, or origin's default as git knows it, or `main`.
+ * @param config - The config.
+ * @param mainRoot - The main checkout.
+ * @returns The branch.
+ * @example baseBranch(config, "/repo") // "main"
+ */
+export declare function baseBranch(config: FlowConfig, mainRoot: string): string;
+/**
+ * Where the steps of the checkout `cwd` is in run.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns The place.
+ * @throws StartError outside git.
+ * @example placeOf(options, out).root
+ */
+export declare function stepPlace(options: Pick<WorktreeOptions, "config" | "cwd">, out: Output): StepPlace;
+/**
+ * `worktree setup [--only <step>]`: prepares this worktree.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns 0, or 1 if a step failed.
+ * @throws UsageError if `--only` names no step.
+ * @example await worktreeSetup(options, out)
+ */
+export declare function worktreeSetup(options: WorktreeOptions, out: Output): Promise<number>;
+/**
+ * `worktree teardown [--path <dir>]`: cleans a worktree before deleting it (its steps, its
+ * ports and its Docker). With `--path` the folder may be gone already; if it is there, it
+ * must be one of the repo's worktrees. Never the main checkout, by any path to it.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns 0, or 1 if something could not be cleaned.
+ * @throws StartError for the main checkout or a folder that is not a worktree.
+ * @example await worktreeTeardown(options, out)
+ */
+export declare function worktreeTeardown(options: WorktreeOptions, out: Output): Promise<number>;
+/**
+ * `worktree ports [--next]`: prints the first port of this worktree's block, fixing it if
+ * it was not yet; with `--next`, moves it to the next free block.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns The exit code.
+ * @throws StartError without ports in the config, in the main checkout, or with no free block.
+ * @example await worktreePorts(options, out)
+ */
+export declare function worktreePorts(options: WorktreeOptions, out: Output): Promise<number>;
+/**
+ * `worktree cleanup [--path <dir>]`: deletes the Docker of worktrees that are gone, or of
+ * one folder.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns 0, or 1 if a project could not be deleted.
+ * @example worktreeCleanup(options, out)
+ */
+export declare function worktreeCleanup(options: WorktreeOptions, out: Output): number;
+/**
+ * `worktree prune [--only <dir>] [--yes]`: deletes the worktrees whose PR was merged or
+ * closed, after asking: their teardown, the folder, the local branch and the session id.
+ * It never touches one with uncommitted changes, unpushed commits, or a lock (a live
+ * session of `claude --worktree` or `issue start`, or by hand), and checks each again just
+ * before deleting it.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns The exit code.
+ * @throws StartError outside git.
+ * @example await worktreePrune(options, out)
+ */
+export declare function worktreePrune(options: WorktreeOptions, out: Output): Promise<number>;

package/dist/commands/worktree.js

@@ -0,0 +1,244 @@
+/**
+ * @file `issue-flow worktree …`: the life of a worktree after `issue start` made it.
+ * `setup` and `teardown` run the steps of the config, `ports` shows or moves its block of
+ * ports, `cleanup` deletes the Docker of worktrees that are gone, and `prune` deletes the
+ * worktrees whose PR was merged or closed. Ported from Abastio's `scripts/worktree.sh`,
+ * `worktree-prune.sh` and `worktree-cleanup.sh`.
+ */
+import { findPr } from "@ramon-sg/github-rest";
+import { confirm } from "../ask.js";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { canonicalPath, dockerCleanup } from "../docker.js";
+import { checkoutRoot, git, isClean, locateRepo, safeToDelete, worktrees } from "../git.js";
+import { forgetSession } from "../launch.js";
+import { UsageError, warn } from "../output.js";
+import { claimPortBase, nextPortBase, portBase } from "../ports.js";
+import { isStale, LOCK_REASON } from "../session-lock.js";
+import { StartError } from "../start-state.js";
+import { runSetup, teardownWorktree } from "../worktree-steps.js";
+/** The reason `claude --worktree` locks the worktrees it makes while its session lives. */
+const CLAUDE_LOCK_REASON = "claude session";
+/**
+ * The base branch: the config's, or origin's default as git knows it, or `main`.
+ * @param config - The config.
+ * @param mainRoot - The main checkout.
+ * @returns The branch.
+ * @example baseBranch(config, "/repo") // "main"
+ */
+export function baseBranch(config, mainRoot) {
+    if (config.baseBranch !== null)
+        return config.baseBranch;
+    const head = git(mainRoot, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]);
+    return head.ok && head.out.startsWith("origin/") ? head.out.slice("origin/".length) : "main";
+}
+/**
+ * Where the steps of the checkout `cwd` is in run.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns The place.
+ * @throws StartError outside git.
+ * @example placeOf(options, out).root
+ */
+export function stepPlace(options, out) {
+    const located = locateRepo(options.cwd);
+    const root = checkoutRoot(options.cwd);
+    if (located === null || root === null)
+        throw new StartError("run this inside a checkout of the repo.");
+    const { mainRoot } = located;
+    return { root, mainRoot, base: baseBranch(options.config, mainRoot), config: options.config, out, remote: process.env.CLAUDE_CODE_REMOTE === "true" };
+}
+/**
+ * `worktree setup [--only <step>]`: prepares this worktree.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns 0, or 1 if a step failed.
+ * @throws UsageError if `--only` names no step.
+ * @example await worktreeSetup(options, out)
+ */
+export async function worktreeSetup(options, out) {
+    const names = options.config.worktrees.setup.map((step) => step.name);
+    if (options.only !== null && !names.includes(options.only))
+        throw new UsageError(`--only expects a setup step of .agents/flow.json (${names.join(", ") || "it has none"}): ${options.only}`);
+    return (await runSetup(stepPlace(options, out), options.only)) ? 0 : 1;
+}
+/**
+ * `worktree teardown [--path <dir>]`: cleans a worktree before deleting it (its steps, its
+ * ports and its Docker). With `--path` the folder may be gone already; if it is there, it
+ * must be one of the repo's worktrees. Never the main checkout, by any path to it.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns 0, or 1 if something could not be cleaned.
+ * @throws StartError for the main checkout or a folder that is not a worktree.
+ * @example await worktreeTeardown(options, out)
+ */
+export async function worktreeTeardown(options, out) {
+    const place = stepPlace(options, out);
+    const root = options.path === null ? place.root : canonicalPath(resolve(options.cwd, options.path));
+    if (root === place.mainRoot)
+        throw new StartError("teardown is for worktrees, not the main checkout.");
+    if (existsSync(root) && !worktrees(place.mainRoot).some((entry) => entry.path === root))
+        throw new StartError(`${root} is not a worktree of this repo.`);
+    return (await teardownWorktree({ ...place, root })) ? 0 : 1;
+}
+/**
+ * `worktree ports [--next]`: prints the first port of this worktree's block, fixing it if
+ * it was not yet; with `--next`, moves it to the next free block.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns The exit code.
+ * @throws StartError without ports in the config, in the main checkout, or with no free block.
+ * @example await worktreePorts(options, out)
+ */
+export async function worktreePorts(options, out) {
+    const ports = options.config.worktrees.ports;
+    if (ports === null)
+        throw new StartError('this repo has no ports for worktrees: add "worktrees.ports" to .agents/flow.json.');
+    const place = stepPlace(options, out);
+    if (place.root === place.mainRoot)
+        throw new StartError("ports are for worktrees, not the main checkout.");
+    const start = options.next ? nextPortBase(ports, portBase(ports, place.root)) : null;
+    const base = await claimPortBase(ports, place.root, start);
+    if (base === null)
+        throw new StartError("no block of ports is free on this machine; delete worktrees you no longer use.");
+    if (options.next)
+        warn(out, `the worktree moves to block ${base}: restart what runs in it.`);
+    out.stdout(`${base}\n`);
+    return 0;
+}
+/**
+ * `worktree cleanup [--path <dir>]`: deletes the Docker of worktrees that are gone, or of
+ * one folder.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns 0, or 1 if a project could not be deleted.
+ * @example worktreeCleanup(options, out)
+ */
+export function worktreeCleanup(options, out) {
+    const result = dockerCleanup(options.config.worktrees.dockerProjects, options.path);
+    if (!result.dockerRunning) {
+        warn(out, "Docker is not running; nothing was cleaned. Start it and run 'issue-flow worktree cleanup'.");
+        return 0;
+    }
+    for (const project of result.removed)
+        out.stdout(`deleted: ${project}\n`);
+    for (const project of result.failed)
+        warn(out, `could not delete ${project}; see what holds it with 'docker ps -a --filter label=com.docker.compose.project=${project}'.`);
+    return result.failed.length === 0 ? 0 : 1;
+}
+/**
+ * Why `prune` leaves a locked worktree alone, or null if it is not locked.
+ * @param entry - The worktree.
+ * @returns The message, or null.
+ */
+function lockedReason(entry) {
+    const { lock, path } = entry;
+    if (lock === null)
+        return null;
+    if (lock.startsWith(`${LOCK_REASON} `))
+        return isStale(lock)
+            ? `locked by an issue-flow session that is gone, not touched: ${path} (free it with: git worktree unlock ${path})`
+            : `in use by a Claude session, not touched: ${path}`;
+    if (lock.startsWith(CLAUDE_LOCK_REASON))
+        return `in use by a Claude session, not touched: ${path}`;
+    return `locked${lock === "" ? "" : ` (${lock})`}, not touched: ${path}`;
+}
+/**
+ * Whether a worktree is as it was when checked: same tip, clean, not locked. Someone may
+ * have gone on working in it while the question was open.
+ * @param mainRoot - The main checkout.
+ * @param doomed - The worktree.
+ * @returns True if it did not change.
+ */
+function unchanged(mainRoot, doomed) {
+    const tip = git(mainRoot, ["rev-parse", "-q", "--verify", `refs/heads/${doomed.branch}`]).out;
+    const entry = worktrees(mainRoot).find((item) => item.path === doomed.path);
+    return tip === doomed.tip && isClean(doomed.path) && entry !== undefined && entry.lock === null;
+}
+/**
+ * The worktrees `prune` may delete: linked, on a branch, not locked, with the last PR of
+ * the branch merged or closed, clean and with nothing unpushed. It says why it skips the
+ * others.
+ * @param options - The options.
+ * @param mainRoot - The main checkout.
+ * @param out - Where to write.
+ * @returns The worktrees.
+ */
+async function pruneCandidates(options, mainRoot, out) {
+    const only = options.only === null ? null : checkoutRoot(options.only);
+    if (options.only !== null && only === null)
+        throw new StartError(`${options.only} is not a worktree.`);
+    const found = [];
+    const unread = [];
+    for (const entry of worktrees(mainRoot).slice(1)) {
+        const { path, branch } = entry;
+        if (branch === null || (only !== null && path !== only))
+            continue;
+        const locked = lockedReason(entry);
+        if (locked !== null) {
+            out.stdout(`${locked}\n`);
+            continue;
+        }
+        const pr = options.repo === null ? null : await findPr(options.repo, branch).catch(() => {
+            unread.push(branch);
+            return null;
+        });
+        if (pr === null || (pr.state !== "MERGED" && pr.state !== "CLOSED"))
+            continue;
+        if (!isClean(path)) {
+            out.stdout(`PR ${pr.state}, but with uncommitted changes, not deleted: ${path}\n`);
+            continue;
+        }
+        if (!safeToDelete(mainRoot, branch, pr.head)) {
+            out.stdout(`PR ${pr.state}, but with commits that are not in origin, not deleted: ${path}\n`);
+            continue;
+        }
+        out.stdout(`PR ${pr.state}: ${path} (${branch})\n`);
+        found.push({ path, branch, tip: git(mainRoot, ["rev-parse", `refs/heads/${branch}`]).out });
+    }
+    if (unread.length > 0)
+        warn(out, `could not read the PRs of ${unread.join(", ")} from GitHub; they were left alone.`);
+    return found;
+}
+/**
+ * `worktree prune [--only <dir>] [--yes]`: deletes the worktrees whose PR was merged or
+ * closed, after asking: their teardown, the folder, the local branch and the session id.
+ * It never touches one with uncommitted changes, unpushed commits, or a lock (a live
+ * session of `claude --worktree` or `issue start`, or by hand), and checks each again just
+ * before deleting it.
+ * @param options - The options.
+ * @param out - Where to write.
+ * @returns The exit code.
+ * @throws StartError outside git.
+ * @example await worktreePrune(options, out)
+ */
+export async function worktreePrune(options, out) {
+    const place = stepPlace(options, out);
+    const { mainRoot } = place;
+    const doomed = await pruneCandidates(options, mainRoot, out);
+    if (doomed.length === 0) {
+        out.stdout("No worktrees to delete.\n");
+        return 0;
+    }
+    if (!options.yes && !(await confirm(out, "Delete the worktrees above with their local branch and their Docker?"))) {
+        out.stdout("Deleted nothing.\n");
+        return 0;
+    }
+    const { commonDir } = locateRepo(mainRoot) ?? { commonDir: "" };
+    for (const item of doomed) {
+        if (!unchanged(mainRoot, item)) {
+            out.stdout(`changed since the check, not deleted: ${item.path}\n`);
+            continue;
+        }
+        await teardownWorktree({ ...place, root: item.path });
+        if (!git(mainRoot, ["worktree", "remove", item.path]).ok) {
+            warn(out, `could not delete ${item.path} (its teardown already ran: its Docker and ports are gone); see 'git -C ${item.path} status'.`);
+            continue;
+        }
+        if (!git(mainRoot, ["branch", "-q", "-D", item.branch]).ok)
+            warn(out, `could not delete the local branch ${item.branch}.`);
+        forgetSession(commonDir, item.branch);
+        out.stdout(`deleted: ${item.path} (${item.branch})\n`);
+    }
+    return 0;
+}

package/dist/config-base.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file What every part of the config's validation shares: where the file lives, its error
+ * and the checks of objects, keys and strings.
+ */
+/** Where the config lives, relative to the repo root. */
+export declare const CONFIG_PATH = ".agents/flow.json";
+/** Error in the config: exits 2 with the message. */
+export declare class ConfigError extends Error {
+}
+/**
+ * Whether a value is a plain object (not null nor an array).
+ * @param value - The value.
+ * @returns True if it is an object.
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks that an object only has known keys.
+ * @param value - The object.
+ * @param known - The keys it may have.
+ * @param where - Its path in the config, for the error (`branch`).
+ * @throws ConfigError if a key is unknown.
+ */
+export declare function onlyKeys(value: Record<string, unknown>, known: string[], where: string): void;
+/**
+ * An optional string of the config.
+ * @param value - The value, or undefined.
+ * @param where - Its path, for the error.
+ * @param fallback - The default.
+ * @returns The value or the default.
+ * @throws ConfigError if it is not a non-empty string.
+ */
+export declare function text<T extends string | null>(value: unknown, where: string, fallback: T): string | T;

package/dist/config-base.js

@@ -0,0 +1,47 @@
+/**
+ * @file What every part of the config's validation shares: where the file lives, its error
+ * and the checks of objects, keys and strings.
+ */
+/** Where the config lives, relative to the repo root. */
+export const CONFIG_PATH = ".agents/flow.json";
+/** Error in the config: exits 2 with the message. */
+export class ConfigError extends Error {
+}
+/**
+ * Whether a value is a plain object (not null nor an array).
+ * @param value - The value.
+ * @returns True if it is an object.
+ */
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Checks that an object only has known keys.
+ * @param value - The object.
+ * @param known - The keys it may have.
+ * @param where - Its path in the config, for the error (`branch`).
+ * @throws ConfigError if a key is unknown.
+ */
+export function onlyKeys(value, known, where) {
+    for (const key of Object.keys(value)) {
+        if (key === "$schema" && where === "")
+            continue;
+        if (!known.includes(key))
+            throw new ConfigError(`${CONFIG_PATH}: unknown key "${where === "" ? key : `${where}.${key}`}". Known: ${known.join(", ")}.`);
+    }
+}
+/**
+ * An optional string of the config.
+ * @param value - The value, or undefined.
+ * @param where - Its path, for the error.
+ * @param fallback - The default.
+ * @returns The value or the default.
+ * @throws ConfigError if it is not a non-empty string.
+ */
+export function text(value, where, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "string" || value.trim() === "")
+        throw new ConfigError(`${CONFIG_PATH}: "${where}" must be a non-empty string.`);
+    return value;
+}

package/dist/config.d.ts

@@ -0,0 +1,63 @@
+import { type WorktreesConfig } from "./worktree-config.js";
+/** Who proposes a branch name when the issue has none: Claude, or the title's slug. */
+export type Namer = "claude" | "title";
+/** How issues map to the branch type: by label first, then by title prefix. */
+export interface TypeRules {
+    labels: Record<string, string>;
+    titlePrefixes: Record<string, string>;
+}
+/** The whole config, with every default applied. */
+export interface FlowConfig {
+    repo: string | null;
+    baseBranch: string | null;
+    branch: {
+        template: string;
+        namer: Namer;
+        claudeModel: string;
+        types: TypeRules;
+    };
+    worktrees: WorktreesConfig;
+    start: {
+        commitMessage: string;
+        prBody: string;
+        prompt: string;
+        resumePrompt: string;
+        summaryPrompt: string;
+        summaryPlanPrompt: string;
+        cloudPrompt: string;
+    };
+    plans: {
+        dirs: string[];
+    };
+    colors: Record<string, string>;
+}
+/** The defaults, the same rules Abastio uses. */
+export declare const DEFAULT_CONFIG: FlowConfig;
+/** The colors a Claude session takes with `/color`. */
+export declare const SESSION_COLORS: string[];
+/**
+ * Validates a parsed config and fills in the defaults.
+ * @param raw - The parsed JSON.
+ * @returns The config.
+ * @throws ConfigError if something is invalid.
+ * @example parseConfig({ branch: { namer: "title" } }).branch.template // "{type}/{number}-{slug}"
+ */
+export declare function parseConfig(raw: unknown): FlowConfig;
+/**
+ * The main checkout of the repo that holds a directory, or null outside git. The config
+ * is always the main checkout's, also from a worktree: a branch cannot change the steps
+ * its own worktree runs.
+ * @param cwd - The directory.
+ * @returns The root.
+ * @example repoRoot("/repo/.claude/worktrees/feat+42-x") // "/repo"
+ */
+export declare function repoRoot(cwd: string): string | null;
+/**
+ * Reads the config of the main checkout of the repo that holds `cwd`. Outside git, or
+ * without the file, every default applies.
+ * @param cwd - A directory inside the checkout.
+ * @returns The config.
+ * @throws ConfigError if the file is not valid JSON or something in it is invalid.
+ * @example loadConfig(process.cwd()).branch.namer // "claude"
+ */
+export declare function loadConfig(cwd: string): FlowConfig;