@williamthorsen/release-kit 6.0.0 → 8.0.0

package/dist/esm/determineBumpFromCommits.js

@@ -1,32 +1,28 @@
 import { determineBumpType } from "./determineBumpType.js";
-import {
-  parseCommitMessage
-} from "./parseCommitMessage.js";
-function determineBumpFromCommits(commits, workTypes, versionPatterns, scopeAliases, options) {
-  const parseOptions = {
-    ...options?.breakingPolicies !== void 0 && { breakingPolicies: options.breakingPolicies },
-    ...options?.onPolicyViolation !== void 0 && { onPolicyViolation: options.onPolicyViolation }
-  };
-  const parsedCommits = [];
-  const unparseable = [];
-  for (const commit of commits) {
-    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases, parseOptions);
-    if (parsed === void 0) {
-      unparseable.push(commit);
-    } else {
-      parsedCommits.push(parsed);
+import { parseCommitMessage, } from "./parseCommitMessage.js";
+export function determineBumpFromCommits(commits, workTypes, versionPatterns, scopeAliases, options) {
+    const parseOptions = {
+        ...(options?.breakingPolicies !== undefined && { breakingPolicies: options.breakingPolicies }),
+        ...(options?.onPolicyViolation !== undefined && { onPolicyViolation: options.onPolicyViolation }),
+    };
+    const parsedCommits = [];
+    const unparseable = [];
+    for (const commit of commits) {
+        const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases, parseOptions);
+        if (parsed === undefined) {
+            unparseable.push(commit);
+        }
+        else {
+            parsedCommits.push(parsed);
+        }
     }
-  }
-  let releaseType = determineBumpType(parsedCommits, workTypes, versionPatterns);
-  if (releaseType === void 0 && commits.length > 0) {
-    releaseType = "patch";
-  }
-  return {
-    releaseType,
-    parsedCommitCount: parsedCommits.length,
-    unparseableCommits: unparseable.length > 0 ? unparseable : void 0
-  };
+    let releaseType = determineBumpType(parsedCommits, workTypes, versionPatterns);
+    if (releaseType === undefined && commits.length > 0) {
+        releaseType = 'patch';
+    }
+    return {
+        releaseType,
+        parsedCommitCount: parsedCommits.length,
+        unparseableCommits: unparseable.length > 0 ? unparseable : undefined,
+    };
 }
-export {
-  determineBumpFromCommits
-};

package/dist/esm/determineBumpType.d.ts

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

package/dist/esm/determineBumpType.js

@@ -1,36 +1,35 @@
 const RELEASE_PRIORITY = {
-  major: 3,
-  minor: 2,
-  patch: 1
+    major: 3,
+    minor: 2,
+    patch: 1,
 };
-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 && versionPatterns.major.includes("!")) {
-      return "major";
+export 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 && versionPatterns.major.includes('!')) {
+            return 'major';
+        }
+        const commitType = commit.type;
+        if (!knownTypes.has(commitType)) {
+            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) {
+            highestPriority = priority;
+            result = bump;
+        }
     }
-    const commitType = commit.type;
-    if (!knownTypes.has(commitType)) {
-      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) {
-      highestPriority = priority;
-      result = bump;
-    }
-  }
-  return result;
+    return result;
 }
-export {
-  determineBumpType
-};

package/dist/esm/discoverWorkspaces.js

@@ -1,43 +1,41 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { glob } from "glob";
-import { parse } from "yaml";
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { glob } from 'glob';
+import { parse } from 'yaml';
 import { isRecord } from "./typeGuards.js";
-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 = parse(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);
-      }
+export async function discoverWorkspaces() {
+    const workspaceFile = 'pnpm-workspace.yaml';
+    if (!existsSync(workspaceFile)) {
+        return undefined;
     }
-  }
-  return directories.length > 0 ? [...directories].sort() : 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 undefined;
+    }
+    const parsed = parse(content);
+    if (!isRecord(parsed)) {
+        return undefined;
+    }
+    const packagesField = parsed.packages;
+    if (!Array.isArray(packagesField)) {
+        return undefined;
+    }
+    const patterns = packagesField.filter((p) => typeof p === 'string');
+    if (patterns.length === 0) {
+        return undefined;
+    }
+    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() : undefined;
 }
-export {
-  discoverWorkspaces
-};

package/dist/esm/format.js

@@ -1,14 +1,9 @@
-function bold(text) {
-  return `\x1B[1m${text}\x1B[0m`;
+export function bold(text) {
+    return `\u001B[1m${text}\u001B[0m`;
 }
-function dim(text) {
-  return `\x1B[2m${text}\x1B[0m`;
+export function dim(text) {
+    return `\u001B[2m${text}\u001B[0m`;
 }
-function sectionHeader(name) {
-  return `\u2501\u2501\u2501 ${name} \u2501\u2501\u2501`;
+export function sectionHeader(name) {
+    return `━━━ ${name} ━━━`;
 }
-export {
-  bold,
-  dim,
-  sectionHeader
-};

package/dist/esm/generateChangelogs.d.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceConfig } from './types.ts';
+import type { WorkspaceConfig } from './types.js';
 export declare function buildTagPattern(tagPrefixes: readonly string[]): string;
 export declare function getAllTagPrefixes(workspace: WorkspaceConfig): string[];
 export interface GenerateChangelogOptions {

package/dist/esm/generateChangelogs.js

@@ -1,21 +1,17 @@
-function buildTagPattern(tagPrefixes) {
-  if (tagPrefixes.length === 0) {
-    throw new Error("buildTagPattern: tagPrefixes must contain at least one entry");
-  }
-  if (tagPrefixes.length === 1) {
-    const single = tagPrefixes[0] ?? "";
-    return `${single}[0-9].*`;
-  }
-  const escaped = tagPrefixes.map(escapeRegex);
-  return `(${escaped.join("|")})[0-9].*`;
+export function buildTagPattern(tagPrefixes) {
+    if (tagPrefixes.length === 0) {
+        throw new Error('buildTagPattern: tagPrefixes must contain at least one entry');
+    }
+    if (tagPrefixes.length === 1) {
+        const single = tagPrefixes[0] ?? '';
+        return `${single}[0-9].*`;
+    }
+    const escaped = tagPrefixes.map(escapeRegex);
+    return `(${escaped.join('|')})[0-9].*`;
 }
-function getAllTagPrefixes(workspace) {
-  return [workspace.tagPrefix, ...workspace.legacyIdentities?.map((identity) => identity.tagPrefix) ?? []];
+export function getAllTagPrefixes(workspace) {
+    return [workspace.tagPrefix, ...(workspace.legacyIdentities?.map((identity) => identity.tagPrefix) ?? [])];
 }
 function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+    return value.replace(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
 }
-export {
-  buildTagPattern,
-  getAllTagPrefixes
-};

package/dist/esm/getCommitsSinceTarget.d.ts

@@ -1,4 +1,4 @@
-import type { Commit } from './types.ts';
+import type { Commit } from './types.js';
 export declare function getCommitsSinceTarget(tagPrefixes: readonly string[], paths?: string[]): {
     tag: string | undefined;
     commits: Commit[];

package/dist/esm/getCommitsSinceTarget.js

@@ -1,66 +1,65 @@
-import { execFileSync } from "node:child_process";
-const FIELD_SEPARATOR = "";
+import { execFileSync } from 'node:child_process';
+const FIELD_SEPARATOR = '\u001F';
 function isNoTagError(err) {
-  return typeof err === "object" && err !== null && "status" in err && err.status === 128;
+    return typeof err === 'object' && err !== null && 'status' in err && err.status === 128;
 }
 function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+    return err instanceof Error ? err.message : String(err);
 }
 function findLatestTag(tagPrefixes) {
-  if (tagPrefixes.length === 0) {
-    throw new Error("findLatestTag: tagPrefixes must contain at least one entry");
-  }
-  const matchArgs = tagPrefixes.map((prefix) => `--match=${prefix}*`);
-  try {
-    const tagResult = execFileSync("git", ["describe", "--tags", "--abbrev=0", ...matchArgs], {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return tagResult || void 0;
-  } catch (error) {
-    if (isNoTagError(error)) {
-      return void 0;
+    if (tagPrefixes.length === 0) {
+        throw new Error('findLatestTag: tagPrefixes must contain at least one entry');
+    }
+    const matchArgs = tagPrefixes.map((prefix) => `--match=${prefix}*`);
+    try {
+        const tagResult = execFileSync('git', ['describe', '--tags', '--abbrev=0', ...matchArgs], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return tagResult || undefined;
+    }
+    catch (error) {
+        if (isNoTagError(error)) {
+            return undefined;
+        }
+        throw new Error(`Failed to run 'git describe': ${errorMessage(error)}`);
     }
-    throw new Error(`Failed to run 'git describe': ${errorMessage(error)}`);
-  }
 }
-const RELEASE_COMMIT_PREFIX = "release:";
+const RELEASE_COMMIT_PREFIX = 'release:';
 function parseLogOutput(logOutput) {
-  const commits = [];
-  for (const line of logOutput.split("\n")) {
-    const trimmedLine = line.trim();
-    if (trimmedLine === "") {
-      continue;
+    const commits = [];
+    for (const line of logOutput.split('\n')) {
+        const trimmedLine = line.trim();
+        if (trimmedLine === '') {
+            continue;
+        }
+        const [message, hash] = trimmedLine.split(FIELD_SEPARATOR);
+        if (message !== undefined && hash !== undefined && !message.startsWith(RELEASE_COMMIT_PREFIX)) {
+            commits.push({ message, hash });
+        }
     }
-    const [message, hash] = trimmedLine.split(FIELD_SEPARATOR);
-    if (message !== void 0 && hash !== void 0 && !message.startsWith(RELEASE_COMMIT_PREFIX)) {
-      commits.push({ message, hash });
-    }
-  }
-  return commits;
+    return commits;
 }
-function getCommitsSinceTarget(tagPrefixes, paths) {
-  const tag = findLatestTag(tagPrefixes);
-  const range = tag === void 0 ? "HEAD" : `${tag}..HEAD`;
-  const format = `%s${FIELD_SEPARATOR}%H`;
-  const args = ["log", range, `--pretty=format:${format}`];
-  if (paths !== void 0 && paths.length > 0) {
-    args.push("--", ...paths);
-  }
-  let logOutput;
-  try {
-    logOutput = execFileSync("git", args, {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch (error) {
-    throw new Error(`Failed to run 'git log' for range '${range}': ${errorMessage(error)}`);
-  }
-  if (logOutput === "") {
-    return { tag, commits: [] };
-  }
-  return { tag, commits: parseLogOutput(logOutput) };
+export function getCommitsSinceTarget(tagPrefixes, paths) {
+    const tag = findLatestTag(tagPrefixes);
+    const range = tag === undefined ? 'HEAD' : `${tag}..HEAD`;
+    const format = `%s${FIELD_SEPARATOR}%H`;
+    const args = ['log', range, `--pretty=format:${format}`];
+    if (paths !== undefined && paths.length > 0) {
+        args.push('--', ...paths);
+    }
+    let logOutput;
+    try {
+        logOutput = execFileSync('git', args, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch (error) {
+        throw new Error(`Failed to run 'git log' for range '${range}': ${errorMessage(error)}`);
+    }
+    if (logOutput === '') {
+        return { tag, commits: [] };
+    }
+    return { tag, commits: parseLogOutput(logOutput) };
 }
-export {
-  getCommitsSinceTarget
-};

package/dist/esm/hasPrettierConfig.js

@@ -1,42 +1,40 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
 import { isRecord } from "./typeGuards.js";
-function hasPrettierConfig() {
-  const cwd = process.cwd();
-  for (const file of PRETTIER_CONFIG_FILES) {
-    if (existsSync(path.join(cwd, file))) {
-      return true;
+export function hasPrettierConfig() {
+    const cwd = process.cwd();
+    for (const file of PRETTIER_CONFIG_FILES) {
+        if (existsSync(path.join(cwd, file))) {
+            return true;
+        }
     }
-  }
-  return hasPrettierKeyInPackageJson(path.join(cwd, "package.json"));
+    return hasPrettierKeyInPackageJson(path.join(cwd, 'package.json'));
 }
 function hasPrettierKeyInPackageJson(packageJsonPath) {
-  if (!existsSync(packageJsonPath)) {
-    return false;
-  }
-  try {
-    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    return isRecord(parsed) && "prettier" in parsed;
-  } catch {
-    return false;
-  }
+    if (!existsSync(packageJsonPath)) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return isRecord(parsed) && 'prettier' in parsed;
+    }
+    catch {
+        return false;
+    }
 }
 const PRETTIER_CONFIG_FILES = [
-  ".prettierrc",
-  ".prettierrc.cjs",
-  ".prettierrc.js",
-  ".prettierrc.json",
-  ".prettierrc.json5",
-  ".prettierrc.mjs",
-  ".prettierrc.toml",
-  ".prettierrc.ts",
-  ".prettierrc.yaml",
-  ".prettierrc.yml",
-  "prettier.config.cjs",
-  "prettier.config.js",
-  "prettier.config.mjs",
-  "prettier.config.ts"
+    '.prettierrc',
+    '.prettierrc.cjs',
+    '.prettierrc.js',
+    '.prettierrc.json',
+    '.prettierrc.json5',
+    '.prettierrc.mjs',
+    '.prettierrc.toml',
+    '.prettierrc.ts',
+    '.prettierrc.yaml',
+    '.prettierrc.yml',
+    'prettier.config.cjs',
+    'prettier.config.js',
+    'prettier.config.mjs',
+    'prettier.config.ts',
 ];
-export {
-  hasPrettierConfig
-};

package/dist/esm/help/prepareHelp.js

@@ -1,4 +1,4 @@
-const prepareHelpText = `
+export const prepareHelpText = `
 Usage: release-kit prepare [options]
 
 Run release preparation with automatic workspace discovery.
@@ -11,7 +11,7 @@ Options:
   --force               Release even when no commits or no bump-worthy commits exist
                          since the last tag. In monorepo and project mode, defaults to
                          patch when --bump is not given; use --bump=X for a different
-                         level. In single-package mode, a bare --force is rejected \u2014
+                         level. In single-package mode, a bare --force is rejected —
                          pass --bump=major|minor|patch.
   --no-git-checks, -n   Skip the clean-working-tree check
   --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only;
@@ -21,10 +21,6 @@ Options:
                          Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).
   --help, -h            Show this help message
 `;
-function showPrepareHelp() {
-  console.info(prepareHelpText);
+export function showPrepareHelp() {
+    console.info(prepareHelpText);
 }
-export {
-  prepareHelpText,
-  showPrepareHelp
-};

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
-export { type ChangelogOverrideScope, validateAllChangelogOverrides, type ValidateAllChangelogOverridesInputs, type ValidateAllChangelogOverridesResult, } from './changelogOverrides.ts';
-export type { SyncLabelsConfig } from './sync-labels/types.ts';
-export type { ReleaseKitConfig } from './types.ts';
-export { formatValidateOverridesResult, type ValidateOverridesCommandResult } from './validateOverridesCommand.ts';
+export { type ChangelogOverrideScope, validateAllChangelogOverrides, type ValidateAllChangelogOverridesInputs, type ValidateAllChangelogOverridesResult, } from './changelogOverrides.js';
+export type { SyncLabelsConfig } from './sync-labels/types.js';
+export type { ReleaseKitConfig } from './types.js';
+export { formatValidateOverridesResult, type ValidateOverridesCommandResult } from './validateOverridesCommand.js';

package/dist/esm/index.js

@@ -1,8 +1,2 @@
-import {
-  validateAllChangelogOverrides
-} from "./changelogOverrides.js";
-import { formatValidateOverridesResult } from "./validateOverridesCommand.js";
-export {
-  formatValidateOverridesResult,
-  validateAllChangelogOverrides
-};
+export { validateAllChangelogOverrides, } from "./changelogOverrides.js";
+export { formatValidateOverridesResult } from "./validateOverridesCommand.js";

package/dist/esm/init/checks.js

@@ -1,36 +1,32 @@
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+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." };
-  }
+export 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." };
+export 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 };
-  }
-  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 };
-  }
-  return {
-    ok: false,
-    message: "This project does not appear to use pnpm. A pnpm-lock.yaml or packageManager field is required."
-  };
+export function usesPnpm() {
+    if (existsSync('pnpm-lock.yaml')) {
+        return { ok: true };
+    }
+    const raw = readFileSync('package.json', 'utf8');
+    const pkg = parseJsonRecord(raw);
+    if (pkg !== undefined && typeof pkg.packageManager === 'string' && pkg.packageManager.startsWith('pnpm')) {
+        return { ok: true };
+    }
+    return {
+        ok: false,
+        message: 'This project does not appear to use pnpm. A pnpm-lock.yaml or packageManager field is required.',
+    };
 }
-export {
-  hasPackageJson,
-  isGitRepo,
-  usesPnpm
-};

package/dist/esm/init/detectRepoType.js

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