@williamthorsen/release-kit 2.1.0 → 2.3.1

package/dist/esm/releasePrepareMono.js

@@ -4,6 +4,7 @@ import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { determineBumpType } from "./determineBumpType.js";
 import { generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { hasPrettierConfig } from "./hasPrettierConfig.js";
 import { parseCommitMessage } from "./parseCommitMessage.js";
 function releasePrepareMono(config, options) {
   const { dryRun, force, bumpOverride } = options;
@@ -11,50 +12,76 @@ function releasePrepareMono(config, options) {
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
   const tags = [];
   const modifiedFiles = [];
+  const components = [];
   for (const component of config.components) {
     const name = component.dir;
-    console.info(`
-Processing component: ${name}`);
-    console.info("  Finding commits since last release...");
     const { tag, commits } = getCommitsSinceTarget(component.tagPrefix, component.paths);
     const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
-    console.info(`  Found ${commits.length} commits ${since}`);
     if (commits.length === 0 && !force) {
-      console.info(`  No changes for ${name} ${since}. Skipping.`);
+      components.push({
+        name,
+        status: "skipped",
+        previousTag: tag,
+        commitCount: 0,
+        bumpedFiles: [],
+        changelogFiles: [],
+        skipReason: `No changes for ${name} ${since}. Skipping.`
+      });
       continue;
     }
     let releaseType;
+    let parsedCommitCount;
     if (bumpOverride === void 0) {
       const parsedCommits = commits.map((c) => parseCommitMessage(c.message, c.hash, workTypes, config.workspaceAliases)).filter((c) => c !== void 0);
-      console.info(`  Parsed ${parsedCommits.length} typed commits`);
+      parsedCommitCount = parsedCommits.length;
       releaseType = determineBumpType(parsedCommits, workTypes, versionPatterns);
     } else {
       releaseType = bumpOverride;
-      console.info(`  Using bump override: ${releaseType}`);
     }
     if (releaseType === void 0) {
-      console.info(`  No release-worthy changes for ${name} ${since}. Skipping.`);
+      components.push({
+        name,
+        status: "skipped",
+        previousTag: tag,
+        commitCount: commits.length,
+        parsedCommitCount,
+        bumpedFiles: [],
+        changelogFiles: [],
+        skipReason: `No release-worthy changes for ${name} ${since}. Skipping.`
+      });
       continue;
     }
-    console.info(`  Bumping versions (${releaseType})...`);
-    const newVersion = bumpAllVersions(component.packageFiles, releaseType, dryRun);
-    const newTag = `${component.tagPrefix}${newVersion}`;
+    const bump = bumpAllVersions(component.packageFiles, releaseType, dryRun);
+    const newTag = `${component.tagPrefix}${bump.newVersion}`;
     tags.push(newTag);
     modifiedFiles.push(...component.packageFiles, ...component.changelogPaths.map((p) => `${p}/CHANGELOG.md`));
-    console.info("  Generating changelogs...");
+    const changelogFiles = [];
     for (const changelogPath of component.changelogPaths) {
-      generateChangelog(config, changelogPath, newTag, dryRun, { includePaths: component.paths });
+      changelogFiles.push(
+        ...generateChangelog(config, changelogPath, newTag, dryRun, { includePaths: component.paths })
+      );
     }
-    console.info(`  Component release prepared: ${newTag}`);
+    components.push({
+      name,
+      status: "released",
+      previousTag: tag,
+      commitCount: commits.length,
+      parsedCommitCount,
+      releaseType,
+      currentVersion: bump.currentVersion,
+      newVersion: bump.newVersion,
+      tag: newTag,
+      bumpedFiles: bump.files,
+      changelogFiles
+    });
   }
-  if (tags.length > 0 && config.formatCommand !== void 0) {
-    const fullCommand = `${config.formatCommand} ${modifiedFiles.join(" ")}`;
+  const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
+  let formatCommand;
+  if (tags.length > 0 && formatCommandStr !== void 0) {
+    const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
     if (dryRun) {
-      console.info(`
-  [dry-run] Would run format command: ${fullCommand}`);
+      formatCommand = { command: fullCommand, executed: false, files: modifiedFiles };
     } else {
-      console.info(`
-  Running format command: ${fullCommand}`);
       try {
         execSync(fullCommand, { stdio: "inherit" });
       } catch (error) {
@@ -62,12 +89,15 @@ Processing component: ${name}`);
           `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
         );
       }
+      formatCommand = { command: fullCommand, executed: true, files: modifiedFiles };
     }
   }
-  const summary = tags.length > 0 ? "Monorepo release preparation complete." : "No components had release-worthy changes.";
-  console.info(`
-${summary}`);
-  return tags;
+  return {
+    components,
+    tags,
+    formatCommand,
+    dryRun
+  };
 }
 export {
   releasePrepareMono

package/dist/esm/reportPrepare.d.ts

@@ -0,0 +1,2 @@
+import type { PrepareResult } from './types.ts';
+export declare function reportPrepare(result: PrepareResult): string;

package/dist/esm/reportPrepare.js

@@ -0,0 +1,120 @@
+import { bold, dim, sectionHeader } from "./format.js";
+function reportPrepare(result) {
+  const isMultiComponent = result.components.some((c) => c.name !== void 0);
+  if (isMultiComponent) {
+    return formatMultiComponent(result);
+  }
+  return formatSingleComponent(result);
+}
+function formatSingleComponent(result) {
+  const lines = [];
+  const component = result.components[0];
+  if (component === void 0) {
+    return "";
+  }
+  const since = component.previousTag === void 0 ? "the beginning" : component.previousTag;
+  lines.push(dim(`Found ${component.commitCount} commits since ${since}`));
+  if (component.parsedCommitCount !== void 0) {
+    lines.push(dim(`  Parsed ${component.parsedCommitCount} typed commits`));
+  }
+  if (component.status === "skipped") {
+    lines.push(`\u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
+    return lines.join("\n");
+  }
+  if (component.parsedCommitCount === void 0 && component.releaseType !== void 0) {
+    lines.push(`  Using bump override: ${component.releaseType}`);
+  }
+  if (component.releaseType !== void 0) {
+    lines.push(dim(`Bumping versions (${component.releaseType})...`));
+  }
+  if (component.currentVersion !== void 0 && component.newVersion !== void 0 && component.releaseType !== void 0) {
+    lines.push(`\u{1F4E6} ${component.currentVersion} \u2192 ${bold(component.newVersion)} (${component.releaseType})`);
+  }
+  formatBumpFiles(lines, component, result.dryRun);
+  lines.push(dim("Generating changelogs..."));
+  formatChangelogFiles(lines, component, result.dryRun);
+  formatFormatCommand(lines, result);
+  lines.push(`\u2705 Release preparation complete.`);
+  if (component.tag !== void 0) {
+    lines.push(`   \u{1F3F7}\uFE0F  ${bold(component.tag)}`);
+  }
+  return lines.join("\n");
+}
+function formatMultiComponent(result) {
+  const lines = [];
+  for (const component of result.components) {
+    if (component.name !== void 0) {
+      lines.push(`
+${sectionHeader(component.name)}`);
+    }
+    const since = component.previousTag === void 0 ? "(no previous release found)" : `since ${component.previousTag}`;
+    lines.push(dim(`  Found ${component.commitCount} commits ${since}`));
+    if (component.status === "skipped") {
+      lines.push(`  \u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
+      continue;
+    }
+    if (component.parsedCommitCount !== void 0) {
+      lines.push(dim(`  Parsed ${component.parsedCommitCount} typed commits`));
+    }
+    if (component.parsedCommitCount === void 0 && component.releaseType !== void 0) {
+      lines.push(`  Using bump override: ${component.releaseType}`);
+    }
+    if (component.releaseType !== void 0) {
+      lines.push(dim(`  Bumping versions (${component.releaseType})...`));
+    }
+    if (component.currentVersion !== void 0 && component.newVersion !== void 0 && component.releaseType !== void 0) {
+      lines.push(`  \u{1F4E6} ${component.currentVersion} \u2192 ${bold(component.newVersion)} (${component.releaseType})`);
+    }
+    formatBumpFiles(lines, component, result.dryRun, "  ");
+    lines.push(dim("  Generating changelogs..."));
+    formatChangelogFiles(lines, component, result.dryRun, "  ");
+    if (component.tag !== void 0) {
+      lines.push(`  \u{1F3F7}\uFE0F  ${bold(component.tag)}`);
+    }
+  }
+  formatFormatCommand(lines, result);
+  if (result.tags.length > 0) {
+    lines.push(`
+\u2705 Release preparation complete.`);
+    for (const tag of result.tags) {
+      lines.push(`   \u{1F3F7}\uFE0F  ${bold(tag)}`);
+    }
+  } else {
+    lines.push(`
+\u23ED\uFE0F  No components had release-worthy changes.`);
+  }
+  return lines.join("\n");
+}
+function formatBumpFiles(lines, component, dryRun, indent = "") {
+  for (const file of component.bumpedFiles) {
+    if (dryRun) {
+      lines.push(dim(`${indent}  [dry-run] Would bump ${file}`));
+    } else {
+      lines.push(dim(`${indent}  Bumped ${file}`));
+    }
+  }
+}
+function formatChangelogFiles(lines, component, dryRun, indent = "") {
+  for (const file of component.changelogFiles) {
+    if (dryRun) {
+      lines.push(dim(`${indent}  [dry-run] Would run: npx --yes git-cliff ... --output ${file}`));
+    } else {
+      lines.push(dim(`${indent}  Generating changelog: ${file}`));
+    }
+  }
+}
+function formatFormatCommand(lines, result) {
+  if (result.formatCommand === void 0) {
+    return;
+  }
+  if (result.formatCommand.executed) {
+    lines.push(dim(`
+  Running format command: ${result.formatCommand.command}`));
+  } else {
+    lines.push(dim(`
+  [dry-run] Would run format command: ${result.formatCommand.command}`));
+  }
+}
+export {
+  reportPrepare
+};

package/dist/esm/resolveCliffConfigPath.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { findPackageRoot } from "./findPackageRoot.js";
 function resolveCliffConfigPath(cliffConfigPath, metaUrl) {
   if (cliffConfigPath !== void 0) {
     return cliffConfigPath;
@@ -11,8 +11,8 @@ function resolveCliffConfigPath(cliffConfigPath, metaUrl) {
       return candidate;
     }
   }
-  const thisDir = dirname(fileURLToPath(metaUrl));
-  const bundledPath = resolve(thisDir, "..", "..", "cliff.toml.template");
+  const root = findPackageRoot(metaUrl);
+  const bundledPath = resolve(root, "cliff.toml.template");
   if (existsSync(bundledPath)) {
     return bundledPath;
   }

package/dist/esm/resolveReleaseTags.d.ts

@@ -0,0 +1,6 @@
+export interface ResolvedTag {
+    tag: string;
+    dir: string;
+    workspacePath: string;
+}
+export declare function resolveReleaseTags(workspaceMap?: Map<string, string>): ResolvedTag[];

package/dist/esm/resolveReleaseTags.js

@@ -0,0 +1,42 @@
+import { execFileSync } from "node:child_process";
+const VERSION_PATTERN = /^v\d+\.\d+\.\d+/;
+function resolveReleaseTags(workspaceMap) {
+  const output = execFileSync("git", ["tag", "--points-at", "HEAD"], { encoding: "utf8" });
+  const tags = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  if (workspaceMap === void 0) {
+    return resolveSinglePackageTags(tags);
+  }
+  return resolveMonorepoTags(tags, workspaceMap);
+}
+function resolveSinglePackageTags(tags) {
+  const matched = tags.filter((tag) => VERSION_PATTERN.test(tag));
+  if (matched.length > 1) {
+    console.warn(
+      `Warning: Multiple version tags found on HEAD: ${matched.join(", ")}. Publishing the same package multiple times is almost certainly unintended. Using only the first tag.`
+    );
+    return matched.slice(0, 1).map((tag) => ({ tag, dir: ".", workspacePath: "." }));
+  }
+  return matched.map((tag) => ({ tag, dir: ".", workspacePath: "." }));
+}
+function resolveMonorepoTags(tags, workspaceMap) {
+  const resolved = [];
+  for (const tag of tags) {
+    const dashV = tag.lastIndexOf("-v");
+    if (dashV === -1) {
+      continue;
+    }
+    const dir = tag.slice(0, dashV);
+    const versionPart = tag.slice(dashV + 1);
+    if (!VERSION_PATTERN.test(versionPart)) {
+      continue;
+    }
+    const workspacePath = workspaceMap.get(dir);
+    if (workspacePath !== void 0) {
+      resolved.push({ tag, dir, workspacePath });
+    }
+  }
+  return resolved;
+}
+export {
+  resolveReleaseTags
+};

package/dist/esm/runReleasePrepare.js

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { dim } from "./format.js";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
 const RELEASE_TAGS_FILE = "tmp/.release-tags";
@@ -109,12 +110,12 @@ function writeReleaseTags(tags, dryRun) {
     return;
   }
   if (dryRun) {
-    console.info(`  [dry-run] Would write ${RELEASE_TAGS_FILE}: ${tags.join(" ")}`);
+    console.info(dim(`  [dry-run] Would write ${RELEASE_TAGS_FILE}: ${tags.join(" ")}`));
     return;
   }
   mkdirSync(dirname(RELEASE_TAGS_FILE), { recursive: true });
   writeFileSync(RELEASE_TAGS_FILE, tags.join("\n"), "utf8");
-  console.info(`  Wrote ${RELEASE_TAGS_FILE}: ${tags.join(" ")}`);
+  console.info(dim(`  Wrote ${RELEASE_TAGS_FILE}: ${tags.join(" ")}`));
 }
 export {
   RELEASE_TAGS_FILE,

package/dist/esm/sync-labels/generateCommand.d.ts

@@ -0,0 +1,4 @@
+import type { LabelDefinition } from './types.ts';
+export declare const LABELS_OUTPUT_PATH = ".github/labels.yaml";
+export declare function formatLabelsYaml(labels: LabelDefinition[]): string;
+export declare function generateCommand(): Promise<number>;

package/dist/esm/sync-labels/generateCommand.js

@@ -0,0 +1,51 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { dump } from "js-yaml";
+import { loadSyncLabelsConfig, SYNC_LABELS_CONFIG_PATH } from "./loadSyncLabelsConfig.js";
+import { resolveLabels } from "./resolveLabels.js";
+const LABELS_OUTPUT_PATH = ".github/labels.yaml";
+const GENERATED_HEADER = `# Generated by release-kit sync-labels \u2014 do not edit.
+# Source: ${SYNC_LABELS_CONFIG_PATH}
+`;
+function formatLabelsYaml(labels) {
+  const yamlBody = dump(labels, { quotingType: '"', forceQuotes: false, lineWidth: -1 });
+  return GENERATED_HEADER + yamlBody;
+}
+async function generateCommand() {
+  let config;
+  try {
+    config = await loadSyncLabelsConfig();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error loading config: ${message}`);
+    return 1;
+  }
+  if (config === void 0) {
+    console.error(`No config file found at ${SYNC_LABELS_CONFIG_PATH}. Run \`release-kit sync-labels init\` first.`);
+    return 1;
+  }
+  let labels;
+  try {
+    labels = resolveLabels(config);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error resolving labels: ${message}`);
+    return 1;
+  }
+  const content = formatLabelsYaml(labels);
+  try {
+    mkdirSync(dirname(LABELS_OUTPUT_PATH), { recursive: true });
+    writeFileSync(LABELS_OUTPUT_PATH, content, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error writing ${LABELS_OUTPUT_PATH}: ${message}`);
+    return 1;
+  }
+  console.info(`Generated ${LABELS_OUTPUT_PATH} with ${String(labels.length)} labels.`);
+  return 0;
+}
+export {
+  LABELS_OUTPUT_PATH,
+  formatLabelsYaml,
+  generateCommand
+};

package/dist/esm/sync-labels/initCommand.d.ts

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

package/dist/esm/sync-labels/initCommand.js

@@ -0,0 +1,62 @@
+import { reportWriteResult, writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
+import { discoverWorkspaces } from "../discoverWorkspaces.js";
+import { generateCommand, LABELS_OUTPUT_PATH } from "./generateCommand.js";
+import { SYNC_LABELS_CONFIG_PATH } from "./loadSyncLabelsConfig.js";
+import { buildScopeLabels, syncLabelsConfigScript, syncLabelsWorkflow } from "./templates.js";
+const WORKFLOW_PATH = ".github/workflows/sync-labels.yaml";
+async function syncLabelsInitCommand({ dryRun, force }) {
+  if (dryRun) {
+    console.info("[dry-run mode]");
+  }
+  console.info("\n> Discovering workspaces");
+  let workspacePaths;
+  try {
+    workspacePaths = await discoverWorkspaces();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`  Failed to discover workspaces: ${message}`);
+    return 1;
+  }
+  const scopeLabels = workspacePaths === void 0 ? [] : buildScopeLabels(workspacePaths);
+  if (workspacePaths === void 0) {
+    console.info("  No pnpm workspaces found (single-package repo)");
+  } else {
+    console.info(`  Found ${String(workspacePaths.length)} workspaces`);
+  }
+  console.info("\n> Scaffolding files");
+  const workflowResult = writeFileWithCheck(WORKFLOW_PATH, syncLabelsWorkflow(), { dryRun, overwrite: force });
+  const configResult = writeFileWithCheck(SYNC_LABELS_CONFIG_PATH, syncLabelsConfigScript(scopeLabels), {
+    dryRun,
+    overwrite: force
+  });
+  reportWriteResult(workflowResult, dryRun);
+  reportWriteResult(configResult, dryRun);
+  if (workflowResult.outcome === "failed" || configResult.outcome === "failed") {
+    console.error("Failed to scaffold one or more files.");
+    return 1;
+  }
+  if (dryRun) {
+    console.info(`
+> [dry-run] Would generate ${LABELS_OUTPUT_PATH}`);
+  } else {
+    console.info("\n> Generating labels");
+    const generateExitCode = await generateCommand();
+    if (generateExitCode !== 0) {
+      return generateExitCode;
+    }
+  }
+  console.info(`
+> Next steps
+  1. Review the generated files:
+     - ${WORKFLOW_PATH}
+     - ${SYNC_LABELS_CONFIG_PATH}
+     - ${LABELS_OUTPUT_PATH}
+  2. Customize ${SYNC_LABELS_CONFIG_PATH} as needed, then re-run \`release-kit sync-labels generate\`.
+  3. Commit the generated files.
+  4. Run \`release-kit sync-labels sync\` to apply labels to your GitHub repo.
+`);
+  return 0;
+}
+export {
+  syncLabelsInitCommand
+};

package/dist/esm/sync-labels/loadSyncLabelsConfig.d.ts

@@ -0,0 +1,3 @@
+import type { SyncLabelsConfig } from './types.ts';
+export declare const SYNC_LABELS_CONFIG_PATH = ".config/sync-labels.config.ts";
+export declare function loadSyncLabelsConfig(): Promise<SyncLabelsConfig | undefined>;

package/dist/esm/sync-labels/loadSyncLabelsConfig.js

@@ -0,0 +1,59 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { isRecord } from "../typeGuards.js";
+const SYNC_LABELS_CONFIG_PATH = ".config/sync-labels.config.ts";
+async function loadSyncLabelsConfig() {
+  const absoluteConfigPath = path.resolve(process.cwd(), SYNC_LABELS_CONFIG_PATH);
+  if (!existsSync(absoluteConfigPath)) {
+    return void 0;
+  }
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(import.meta.url);
+  const imported = await jiti.import(absoluteConfigPath);
+  if (!isRecord(imported)) {
+    throw new Error(`Config file must export an object, got ${Array.isArray(imported) ? "array" : typeof imported}`);
+  }
+  const resolved = imported.default ?? imported.config;
+  if (resolved === void 0) {
+    throw new Error(
+      "Config file must have a default export or a named `config` export (e.g., `export default { ... }` or `export const config = { ... }`)"
+    );
+  }
+  return validateSyncLabelsConfig(resolved);
+}
+function validateSyncLabelsConfig(value) {
+  if (!isRecord(value)) {
+    throw new Error(`Config must be an object, got ${typeof value}`);
+  }
+  let presets;
+  if (value.presets !== void 0) {
+    if (!Array.isArray(value.presets) || !value.presets.every((p) => typeof p === "string")) {
+      throw new Error("Config `presets` must be an array of strings");
+    }
+    presets = value.presets;
+  }
+  let labels;
+  if (value.labels !== void 0) {
+    if (!Array.isArray(value.labels)) {
+      throw new TypeError("Config `labels` must be an array");
+    }
+    labels = [];
+    for (const label of value.labels) {
+      if (!isRecord(label)) {
+        throw new Error("Each label must be an object with `name`, `color`, and `description`");
+      }
+      if (typeof label.name !== "string" || typeof label.color !== "string" || typeof label.description !== "string") {
+        throw new TypeError("Each label must have string `name`, `color`, and `description` fields");
+      }
+      labels.push({ name: label.name, color: label.color, description: label.description });
+    }
+  }
+  return {
+    ...presets !== void 0 && { presets },
+    ...labels !== void 0 && { labels }
+  };
+}
+export {
+  SYNC_LABELS_CONFIG_PATH,
+  loadSyncLabelsConfig
+};

package/dist/esm/sync-labels/presets.d.ts

@@ -0,0 +1,2 @@
+import type { LabelDefinition } from './types.ts';
+export declare function loadPreset(presetName: string): LabelDefinition[];

package/dist/esm/sync-labels/presets.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { load } from "js-yaml";
+import { findPackageRoot } from "../findPackageRoot.js";
+import { isRecord } from "../typeGuards.js";
+function resolvePresetPath(presetName) {
+  const root = findPackageRoot(import.meta.url);
+  return resolve(root, "presets", "labels", `${presetName}.yaml`);
+}
+function loadPreset(presetName) {
+  const presetPath = resolvePresetPath(presetName);
+  if (!existsSync(presetPath)) {
+    throw new Error(`Unknown preset "${presetName}". No file found at ${presetPath}`);
+  }
+  let content;
+  try {
+    content = readFileSync(presetPath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read preset "${presetName}": ${message}`);
+  }
+  const parsed = load(content);
+  if (!Array.isArray(parsed)) {
+    throw new TypeError(`Preset "${presetName}" must be a YAML array of label definitions`);
+  }
+  const labels = [];
+  for (const entry of parsed) {
+    if (!isRecord(entry)) {
+      throw new Error(`Preset "${presetName}" contains an invalid label entry: ${JSON.stringify(entry)}`);
+    }
+    if (typeof entry.name !== "string" || typeof entry.color !== "string" || typeof entry.description !== "string") {
+      throw new TypeError(`Preset "${presetName}" contains a label with invalid fields: ${JSON.stringify(entry)}`);
+    }
+    labels.push({ name: entry.name, color: entry.color, description: entry.description });
+  }
+  return labels;
+}
+export {
+  loadPreset
+};

package/dist/esm/sync-labels/resolveLabels.d.ts

@@ -0,0 +1,2 @@
+import type { LabelDefinition, SyncLabelsConfig } from './types.ts';
+export declare function resolveLabels(config: SyncLabelsConfig): LabelDefinition[];

package/dist/esm/sync-labels/resolveLabels.js

@@ -0,0 +1,43 @@
+import { loadPreset } from "./presets.js";
+function resolveLabels(config) {
+  const presetLabels = [];
+  for (const presetName of config.presets ?? []) {
+    const loaded = loadPreset(presetName);
+    presetLabels.push(...loaded);
+  }
+  const customLabels = config.labels ?? [];
+  detectCollisions(presetLabels, customLabels);
+  return sortLabels([...presetLabels, ...customLabels]);
+}
+function detectCollisions(presetLabels, customLabels) {
+  const seenPresetNames = /* @__PURE__ */ new Set();
+  const withinPresetDuplicates = [];
+  for (const label of presetLabels) {
+    if (seenPresetNames.has(label.name)) {
+      withinPresetDuplicates.push(label.name);
+    }
+    seenPresetNames.add(label.name);
+  }
+  if (withinPresetDuplicates.length > 0) {
+    throw new Error(
+      `Label name collision within presets: the following labels are defined by multiple presets: ${withinPresetDuplicates.join(", ")}. Remove the duplicates or use different presets.`
+    );
+  }
+  const conflicts = [];
+  for (const label of customLabels) {
+    if (seenPresetNames.has(label.name)) {
+      conflicts.push(label.name);
+    }
+  }
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Label name collision: the following labels appear in both presets and custom labels: ${conflicts.join(", ")}. Remove duplicates from your custom labels or use a different name.`
+    );
+  }
+}
+function sortLabels(labels) {
+  return [...labels].sort((a, b) => a.name.localeCompare(b.name));
+}
+export {
+  resolveLabels
+};

package/dist/esm/sync-labels/scaffold.d.ts

@@ -0,0 +1,6 @@
+interface WriteResult {
+    action: 'created' | 'skipped' | 'dry-run' | 'failed';
+    filePath: string;
+}
+export declare function writeIfAbsent(filePath: string, content: string, dryRun: boolean, overwrite: boolean): WriteResult;
+export {};

package/dist/esm/sync-labels/scaffold.js

@@ -0,0 +1,25 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function writeIfAbsent(filePath, content, dryRun, overwrite) {
+  if (existsSync(filePath) && !overwrite) {
+    console.info(`  Skipped ${filePath} (already exists)`);
+    return { action: "skipped", filePath };
+  }
+  if (dryRun) {
+    console.info(`  [dry-run] Would create ${filePath}`);
+    return { action: "dry-run", filePath };
+  }
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`  Failed to write ${filePath}: ${message}`);
+    return { action: "failed", filePath };
+  }
+  console.info(`  Created ${filePath}`);
+  return { action: "created", filePath };
+}
+export {
+  writeIfAbsent
+};

package/dist/esm/sync-labels/syncCommand.d.ts

@@ -0,0 +1 @@
+export declare function syncLabelsCommand(): number;