@williamthorsen/release-kit 0.2.2 → 1.0.0

package/dist/esm/component.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentConfig } from './types.ts';
+export declare function component(workspacePath: string, tagPrefix?: string): ComponentConfig;

package/dist/esm/component.js

@@ -0,0 +1,15 @@
+import { basename } from "node:path";
+function component(workspacePath, tagPrefix) {
+  const dir = basename(workspacePath);
+  const prefix = tagPrefix ?? `${dir}-v`;
+  return {
+    dir,
+    tagPrefix: prefix,
+    packageFiles: [`${workspacePath}/package.json`],
+    changelogPaths: [workspacePath],
+    paths: [`${workspacePath}/**`]
+  };
+}
+export {
+  component
+};

package/dist/esm/defaults.d.ts

@@ -1,2 +1,3 @@
-import type { WorkTypeConfig } from './types.ts';
-export declare const DEFAULT_WORK_TYPES: readonly WorkTypeConfig[];
+import type { VersionPatterns, WorkTypeConfig } from './types.ts';
+export declare const DEFAULT_WORK_TYPES: Record<string, WorkTypeConfig>;
+export declare const DEFAULT_VERSION_PATTERNS: VersionPatterns;

package/dist/esm/defaults.js

@@ -1,15 +1,20 @@
-const DEFAULT_WORK_TYPES = [
-  { type: "fix", header: "Bug fixes", bump: "patch", aliases: ["bugfix"] },
-  { type: "feat", header: "Features", bump: "minor", aliases: ["feature"] },
-  { type: "internal", header: "Internal", bump: "patch" },
-  { type: "refactor", header: "Refactoring", bump: "patch" },
-  { type: "tests", header: "Tests", bump: "patch", aliases: ["test"] },
-  { type: "tooling", header: "Tooling", bump: "patch" },
-  { type: "ci", header: "CI", bump: "patch" },
-  { type: "deps", header: "Dependencies", bump: "patch", aliases: ["dep"] },
-  { type: "docs", header: "Documentation", bump: "patch", aliases: ["doc"] },
-  { type: "fmt", header: "Formatting", bump: "patch" }
-];
+const DEFAULT_WORK_TYPES = {
+  fix: { header: "Bug fixes", aliases: ["bugfix"] },
+  feat: { header: "Features", aliases: ["feature"] },
+  internal: { header: "Internal" },
+  refactor: { header: "Refactoring" },
+  tests: { header: "Tests", aliases: ["test"] },
+  tooling: { header: "Tooling" },
+  ci: { header: "CI" },
+  deps: { header: "Dependencies", aliases: ["dep"] },
+  docs: { header: "Documentation", aliases: ["doc"] },
+  fmt: { header: "Formatting" }
+};
+const DEFAULT_VERSION_PATTERNS = {
+  major: ["!"],
+  minor: ["feat", "feature"]
+};
 export {
+  DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES
 };

package/dist/esm/determineBumpType.d.ts

@@ -1,2 +1,2 @@
-import type { ParsedCommit, ReleaseType, WorkTypeConfig } from './types.ts';
-export declare function determineBumpType(commits: readonly ParsedCommit[], workTypes: readonly WorkTypeConfig[]): ReleaseType | undefined;
+import type { ParsedCommit, ReleaseType, VersionPatterns, WorkTypeConfig } from './types.ts';
+export declare function determineBumpType(commits: readonly ParsedCommit[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns): ReleaseType | undefined;

package/dist/esm/determineBumpType.js

@@ -3,24 +3,25 @@ const RELEASE_PRIORITY = {
   minor: 2,
   patch: 1
 };
-function determineBumpType(commits, workTypes) {
-  const typeToBump = {};
-  for (const config of workTypes) {
-    typeToBump[config.type] = config.bump;
-  }
+function determineBumpType(commits, workTypes, versionPatterns) {
+  const knownTypes = new Set(Object.keys(workTypes));
   let highestPriority = 0;
   let result;
   for (const commit of commits) {
-    if (commit.breaking) {
+    if (commit.breaking && versionPatterns.major.includes("!")) {
       return "major";
     }
     const commitType = commit.type;
-    if (!isKeyOf(commitType, typeToBump)) {
+    if (!knownTypes.has(commitType)) {
       continue;
     }
-    const bump = typeToBump[commitType];
-    if (bump === void 0) {
-      continue;
+    let bump;
+    if (versionPatterns.major.includes(commitType)) {
+      bump = "major";
+    } else if (versionPatterns.minor.includes(commitType)) {
+      bump = "minor";
+    } else {
+      bump = "patch";
     }
     const priority = RELEASE_PRIORITY[bump];
     if (priority > highestPriority) {
@@ -30,9 +31,6 @@ function determineBumpType(commits, workTypes) {
   }
   return result;
 }
-function isKeyOf(key, obj) {
-  return Object.hasOwn(obj, key);
-}
 export {
   determineBumpType
 };

package/dist/esm/discoverWorkspaces.d.ts

@@ -0,0 +1 @@
+export declare function discoverWorkspaces(): Promise<string[] | undefined>;

package/dist/esm/discoverWorkspaces.js

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { glob } from "glob";
+import { load } from "js-yaml";
+async function discoverWorkspaces() {
+  const workspaceFile = "pnpm-workspace.yaml";
+  if (!existsSync(workspaceFile)) {
+    return void 0;
+  }
+  let content;
+  try {
+    content = readFileSync(workspaceFile, "utf8");
+  } catch (error) {
+    console.warn(`Warning: Failed to read ${workspaceFile}: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+  const parsed = load(content);
+  if (!isRecord(parsed)) {
+    return void 0;
+  }
+  const packagesField = parsed.packages;
+  if (!Array.isArray(packagesField)) {
+    return void 0;
+  }
+  const patterns = packagesField.filter((p) => typeof p === "string");
+  if (patterns.length === 0) {
+    return void 0;
+  }
+  const directories = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, { posix: true });
+    for (const match of matches) {
+      if (existsSync(join(match, "package.json"))) {
+        directories.push(match);
+      }
+    }
+  }
+  return directories.length > 0 ? [...directories].sort() : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  discoverWorkspaces
+};

package/dist/esm/getCommitsSinceTarget.js

@@ -20,6 +20,7 @@ function findLatestTag(tagPrefix) {
     throw new Error(`Failed to run 'git describe': ${errorMessage(error)}`);
   }
 }
+const RELEASE_COMMIT_PREFIX = "release:";
 function parseLogOutput(logOutput) {
   const commits = [];
   for (const line of logOutput.split("\n")) {
@@ -28,7 +29,7 @@ function parseLogOutput(logOutput) {
       continue;
     }
     const [message, hash] = trimmedLine.split(FIELD_SEPARATOR);
-    if (message !== void 0 && hash !== void 0) {
+    if (message !== void 0 && hash !== void 0 && !message.startsWith(RELEASE_COMMIT_PREFIX)) {
       commits.push({ message, hash });
     }
   }

package/dist/esm/index.d.ts

@@ -1,12 +1,15 @@
 export type { GenerateChangelogOptions } from './generateChangelogs.ts';
 export type { ReleasePrepareOptions } from './releasePrepare.ts';
-export type { Commit, ComponentConfig, MonorepoReleaseConfig, ParsedCommit, ReleaseConfig, ReleaseType, WorkTypeConfig, } from './types.ts';
-export { DEFAULT_WORK_TYPES } from './defaults.ts';
+export type { Commit, ComponentConfig, ComponentOverride, MonorepoReleaseConfig, ParsedCommit, ReleaseConfig, ReleaseKitConfig, ReleaseType, VersionPatterns, WorkTypeConfig, } from './types.ts';
+export { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from './defaults.ts';
 export { bumpAllVersions } from './bumpAllVersions.ts';
 export { bumpVersion } from './bumpVersion.ts';
+export { component } from './component.ts';
 export { determineBumpType } from './determineBumpType.ts';
+export { discoverWorkspaces } from './discoverWorkspaces.ts';
 export { generateChangelog, generateChangelogs } from './generateChangelogs.ts';
 export { getCommitsSinceTarget } from './getCommitsSinceTarget.ts';
 export { parseCommitMessage } from './parseCommitMessage.ts';
 export { releasePrepare } from './releasePrepare.ts';
 export { releasePrepareMono } from './releasePrepareMono.ts';
+export { RELEASE_TAGS_FILE, runReleasePrepare, writeReleaseTags } from './runReleasePrepare.ts';

package/dist/esm/index.js

@@ -1,21 +1,30 @@
-import { DEFAULT_WORK_TYPES } from "./defaults.js";
+import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { bumpVersion } from "./bumpVersion.js";
+import { component } from "./component.js";
 import { determineBumpType } from "./determineBumpType.js";
+import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { generateChangelog, generateChangelogs } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { parseCommitMessage } from "./parseCommitMessage.js";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
+import { RELEASE_TAGS_FILE, runReleasePrepare, writeReleaseTags } from "./runReleasePrepare.js";
 export {
+  DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES,
+  RELEASE_TAGS_FILE,
   bumpAllVersions,
   bumpVersion,
+  component,
   determineBumpType,
+  discoverWorkspaces,
   generateChangelog,
   generateChangelogs,
   getCommitsSinceTarget,
   parseCommitMessage,
   releasePrepare,
-  releasePrepareMono
+  releasePrepareMono,
+  runReleasePrepare,
+  writeReleaseTags
 };

package/dist/esm/init/checks.d.ts

@@ -0,0 +1,9 @@
+export interface CheckResult {
+    ok: boolean;
+    message?: string;
+}
+export declare function isGitRepo(): CheckResult;
+export declare function hasPackageJson(): CheckResult;
+export declare function usesPnpm(): CheckResult;
+export declare function hasCliffToml(): CheckResult;
+export declare function notAlreadyInitialized(): CheckResult;

package/dist/esm/init/checks.js

@@ -0,0 +1,56 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { parseJsonRecord } from "./parseJsonRecord.js";
+function isGitRepo() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
+    return { ok: true };
+  } catch {
+    return { ok: false, message: "Not inside a git repository. Run `git init` first." };
+  }
+}
+function hasPackageJson() {
+  if (existsSync("package.json")) {
+    return { ok: true };
+  }
+  return { ok: false, message: "No package.json found. Run `npm init` or `pnpm init` first." };
+}
+function usesPnpm() {
+  if (existsSync("pnpm-lock.yaml")) {
+    return { ok: true };
+  }
+  try {
+    const raw = readFileSync("package.json", "utf8");
+    const pkg = parseJsonRecord(raw);
+    if (pkg !== void 0 && typeof pkg.packageManager === "string" && pkg.packageManager.startsWith("pnpm")) {
+      return { ok: true };
+    }
+  } catch {
+  }
+  return {
+    ok: false,
+    message: "This project does not appear to use pnpm. A pnpm-lock.yaml or packageManager field is required."
+  };
+}
+function hasCliffToml() {
+  if (existsSync("cliff.toml")) {
+    return { ok: true };
+  }
+  return { ok: false, message: "No cliff.toml found. This file is required for changelog generation." };
+}
+function notAlreadyInitialized() {
+  if (!existsSync(".config/release-kit.config.ts") && !existsSync(".github/scripts/release.config.ts")) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    message: "release-kit appears to be already initialized."
+  };
+}
+export {
+  hasCliffToml,
+  hasPackageJson,
+  isGitRepo,
+  notAlreadyInitialized,
+  usesPnpm
+};

package/dist/esm/init/detectRepoType.d.ts

@@ -0,0 +1,2 @@
+export type RepoType = 'monorepo' | 'single-package';
+export declare function detectRepoType(): RepoType;

package/dist/esm/init/detectRepoType.js

@@ -0,0 +1,19 @@
+import { existsSync, readFileSync } from "node:fs";
+import { parseJsonRecord } from "./parseJsonRecord.js";
+function detectRepoType() {
+  if (existsSync("pnpm-workspace.yaml")) {
+    return "monorepo";
+  }
+  try {
+    const raw = readFileSync("package.json", "utf8");
+    const pkg = parseJsonRecord(raw);
+    if (pkg !== void 0 && Array.isArray(pkg.workspaces)) {
+      return "monorepo";
+    }
+  } catch {
+  }
+  return "single-package";
+}
+export {
+  detectRepoType
+};

package/dist/esm/init/initCommand.d.ts

@@ -0,0 +1,5 @@
+interface InitOptions {
+    dryRun: boolean;
+}
+export declare function initCommand({ dryRun }: InitOptions): Promise<number>;
+export {};

package/dist/esm/init/initCommand.js

@@ -0,0 +1,65 @@
+import { hasCliffToml, hasPackageJson, isGitRepo, notAlreadyInitialized, usesPnpm } from "./checks.js";
+import { detectRepoType } from "./detectRepoType.js";
+import { confirm, printError, printStep, printSuccess } from "./prompt.js";
+import { copyCliffTemplate, scaffoldFiles } from "./scaffold.js";
+function runRequiredCheck(label, result) {
+  if (result.ok) {
+    printSuccess(label);
+    return true;
+  }
+  printError(result.message ?? `${label} failed`);
+  return false;
+}
+async function checkEligibility(dryRun) {
+  printStep("Checking eligibility");
+  if (!runRequiredCheck("Git repository detected", isGitRepo())) return { status: "fail", overwrite: false };
+  if (!runRequiredCheck("package.json found", hasPackageJson())) return { status: "fail", overwrite: false };
+  if (!runRequiredCheck("pnpm detected", usesPnpm())) return { status: "fail", overwrite: false };
+  const cliffCheck = hasCliffToml();
+  if (cliffCheck.ok) {
+    printSuccess("cliff.toml found");
+  } else {
+    console.info("");
+    const shouldCreate = await confirm("No cliff.toml found. Create one from the bundled template?");
+    if (shouldCreate) {
+      copyCliffTemplate(dryRun);
+    } else {
+      printError("cliff.toml is required for changelog generation. Aborting.");
+      return { status: "fail", overwrite: false };
+    }
+  }
+  const initCheck = notAlreadyInitialized();
+  if (!initCheck.ok) {
+    console.info("");
+    const shouldOverwrite = await confirm("release-kit appears to be already initialized. Overwrite existing files?");
+    if (!shouldOverwrite) {
+      console.info("Aborting.");
+      return { status: "abort", overwrite: false };
+    }
+    return { status: "pass", overwrite: true };
+  }
+  return { status: "pass", overwrite: false };
+}
+async function initCommand({ dryRun }) {
+  if (dryRun) {
+    console.info("[dry-run mode]");
+  }
+  const eligibility = await checkEligibility(dryRun);
+  if (eligibility.status === "fail") return 1;
+  if (eligibility.status === "abort") return 0;
+  printStep("Detecting repo type");
+  const repoType = detectRepoType();
+  printSuccess(`Detected: ${repoType}`);
+  printStep("Scaffolding files");
+  scaffoldFiles({ repoType, dryRun, overwrite: eligibility.overwrite });
+  printStep("Next steps");
+  console.info(`
+  1. (Optional) Customize .config/release-kit.config.ts to exclude components, override version patterns, add custom work types, etc.
+  2. Test by running: npx @williamthorsen/release-kit prepare --dry-run
+  3. Commit the generated workflow file (and config file if created).
+`);
+  return 0;
+}
+export {
+  initCommand
+};

package/dist/esm/init/parseJsonRecord.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonRecord(raw: string): Record<string, unknown> | undefined;

package/dist/esm/init/parseJsonRecord.js

@@ -0,0 +1,15 @@
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonRecord(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  return isRecord(parsed) ? parsed : void 0;
+}
+export {
+  parseJsonRecord
+};

package/dist/esm/init/prompt.d.ts

@@ -0,0 +1,5 @@
+export declare function confirm(question: string): Promise<boolean>;
+export declare function printStep(message: string): void;
+export declare function printSuccess(message: string): void;
+export declare function printSkip(message: string): void;
+export declare function printError(message: string): void;

package/dist/esm/init/prompt.js

@@ -0,0 +1,30 @@
+import { createInterface } from "node:readline/promises";
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${question} (y/n) `);
+    return answer.trim().toLowerCase().startsWith("y");
+  } finally {
+    rl.close();
+  }
+}
+function printStep(message) {
+  console.info(`
+> ${message}`);
+}
+function printSuccess(message) {
+  console.info(`  [ok] ${message}`);
+}
+function printSkip(message) {
+  console.info(`  [skip] ${message}`);
+}
+function printError(message) {
+  console.error(`  [error] ${message}`);
+}
+export {
+  confirm,
+  printError,
+  printSkip,
+  printStep,
+  printSuccess
+};

package/dist/esm/init/scaffold.d.ts

@@ -0,0 +1,9 @@
+import type { RepoType } from './detectRepoType.ts';
+interface ScaffoldOptions {
+    repoType: RepoType;
+    dryRun: boolean;
+    overwrite: boolean;
+}
+export declare function copyCliffTemplate(dryRun: boolean): void;
+export declare function scaffoldFiles({ repoType, dryRun, overwrite }: ScaffoldOptions): void;
+export {};

package/dist/esm/init/scaffold.js

@@ -0,0 +1,65 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { printError, printSkip, printSuccess } from "./prompt.js";
+import { releaseConfigScript, releaseWorkflow } from "./templates.js";
+function tryWriteFile(filePath, content) {
+  try {
+    writeFileSync(filePath, content, "utf8");
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Failed to write ${filePath}: ${message}`);
+    return false;
+  }
+}
+function writeIfAbsent(filePath, content, dryRun, overwrite) {
+  if (existsSync(filePath) && !overwrite) {
+    printSkip(`${filePath} (already exists)`);
+    return;
+  }
+  if (dryRun) {
+    printSuccess(`[dry-run] Would create ${filePath}`);
+    return;
+  }
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Failed to create directory for ${filePath}: ${message}`);
+    return;
+  }
+  if (tryWriteFile(filePath, content)) {
+    printSuccess(`Created ${filePath}`);
+  }
+}
+function copyCliffTemplate(dryRun) {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const templatePath = resolve(thisDir, "..", "..", "..", "cliff.toml.template");
+  if (!existsSync(templatePath)) {
+    printError(`Could not find cliff.toml.template at ${templatePath}`);
+    return;
+  }
+  let content;
+  try {
+    content = readFileSync(templatePath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Failed to read cliff.toml.template: ${message}`);
+    return;
+  }
+  writeIfAbsent("cliff.toml", content, dryRun, false);
+}
+function scaffoldFiles({ repoType, dryRun, overwrite }) {
+  const files = [
+    { path: ".config/release-kit.config.ts", content: releaseConfigScript(repoType) },
+    { path: ".github/workflows/release.yaml", content: releaseWorkflow(repoType) }
+  ];
+  for (const file of files) {
+    writeIfAbsent(file.path, file.content, dryRun, overwrite);
+  }
+}
+export {
+  copyCliffTemplate,
+  scaffoldFiles
+};

package/dist/esm/init/templates.d.ts

@@ -0,0 +1,3 @@
+import type { RepoType } from './detectRepoType.ts';
+export declare function releaseConfigScript(repoType: RepoType): string;
+export declare function releaseWorkflow(repoType: RepoType): string;

package/dist/esm/init/templates.js

@@ -0,0 +1,105 @@
+function releaseConfigScript(repoType) {
+  if (repoType === "monorepo") {
+    return `import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
+
+const config: ReleaseKitConfig = {
+  // Uncomment to exclude components from release processing:
+  // components: [
+  //   { dir: 'my-package', shouldExclude: true },
+  // ],
+  // Uncomment to override the default version patterns:
+  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
+  // Uncomment to add custom work types (merged with defaults):
+  // workTypes: { perf: { header: 'Performance' } },
+  // TODO: Uncomment and adjust if you have a format command
+  // formatCommand: 'pnpm run fmt',
+};
+
+export default config;
+`;
+  }
+  return `import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
+
+const config: ReleaseKitConfig = {
+  // Uncomment to override the default version patterns:
+  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
+  // Uncomment to add custom work types (merged with defaults):
+  // workTypes: { perf: { header: 'Performance' } },
+  // TODO: Uncomment and adjust if you have a format command
+  // formatCommand: 'pnpm run fmt',
+};
+
+export default config;
+`;
+}
+function releaseWorkflow(repoType) {
+  if (repoType === "monorepo") {
+    return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      only:
+        description: 'Components to release (comma-separated, leave empty for all)'
+        required: false
+        type: string
+      bump:
+        description: 'Override version bump type (leave empty to auto-detect from commits)'
+        required: false
+        type: choice
+        options:
+          - ''
+          - patch
+          - minor
+          - major
+
+permissions:
+  contents: write
+  packages: read
+
+jobs:
+  release:
+    uses: williamthorsen/.github/.github/workflows/release-pnpm.yaml@v2
+    with:
+      # TODO: Set the Node.js and pnpm versions for your project
+      node-version: '24'
+      pnpm-version: '10.32.1'
+      only: \${{ inputs.only }}
+      bump: \${{ inputs.bump }}
+`;
+  }
+  return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      bump:
+        description: 'Override version bump type (leave empty to auto-detect from commits)'
+        required: false
+        type: choice
+        options:
+          - ''
+          - patch
+          - minor
+          - major
+
+permissions:
+  contents: write
+  packages: read
+
+jobs:
+  release:
+    uses: williamthorsen/.github/.github/workflows/release-pnpm.yaml@v2
+    with:
+      # TODO: Set the Node.js and pnpm versions for your project
+      node-version: '24'
+      pnpm-version: '10.32.1'
+      bump: \${{ inputs.bump }}
+`;
+}
+export {
+  releaseConfigScript,
+  releaseWorkflow
+};

package/dist/esm/loadConfig.d.ts

@@ -0,0 +1,5 @@
+import type { MonorepoReleaseConfig, ReleaseConfig, ReleaseKitConfig } from './types.ts';
+export declare const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
+export declare function loadConfig(): Promise<unknown>;
+export declare function mergeMonorepoConfig(discoveredPaths: string[], userConfig: ReleaseKitConfig | undefined): MonorepoReleaseConfig;
+export declare function mergeSinglePackageConfig(userConfig: ReleaseKitConfig | undefined): ReleaseConfig;