@williamthorsen/release-kit 4.8.0 → 5.0.0

package/dist/esm/validateConfig.js

@@ -8,11 +8,12 @@ function validateConfig(raw) {
   const knownFields = /* @__PURE__ */ new Set([
     "changelogJson",
     "cliffConfigPath",
-    "components",
     "formatCommand",
     "releaseNotes",
+    "retiredPackages",
     "scopeAliases",
     "versionPatterns",
+    "workspaces",
     "workTypes"
   ]);
   for (const key of Object.keys(raw)) {
@@ -21,26 +22,20 @@ function validateConfig(raw) {
     }
   }
   validateChangelogJson(raw.changelogJson, config, errors);
-  validateComponents(raw.components, config, errors);
+  validateWorkspaces(raw.workspaces, config, errors);
   validateReleaseNotes(raw.releaseNotes, config, errors);
   validateVersionPatterns(raw.versionPatterns, config, errors);
   validateWorkTypes(raw.workTypes, config, errors);
   validateStringField("formatCommand", raw.formatCommand, config, errors);
   validateStringField("cliffConfigPath", raw.cliffConfigPath, config, errors);
   validateScopeAliases(raw.scopeAliases, config, errors);
+  validateRetiredPackages(raw.retiredPackages, config, errors);
   const warnings = [];
   const changelogJsonEnabled = config.changelogJson?.enabled ?? true;
-  if (!changelogJsonEnabled) {
-    if (config.releaseNotes?.shouldCreateGithubRelease) {
-      warnings.push(
-        "releaseNotes.shouldCreateGithubRelease is enabled but changelogJson.enabled is false; GitHub Releases will be skipped at runtime"
-      );
-    }
-    if (config.releaseNotes?.shouldInjectIntoReadme) {
-      warnings.push(
-        "releaseNotes.shouldInjectIntoReadme is enabled but changelogJson.enabled is false; README injection will be skipped at runtime"
-      );
-    }
+  if (!changelogJsonEnabled && config.releaseNotes?.shouldInjectIntoReadme) {
+    warnings.push(
+      "releaseNotes.shouldInjectIntoReadme is enabled but changelogJson.enabled is false; README injection will be skipped at runtime"
+    );
   }
   return { config, errors, warnings };
 }
@@ -86,10 +81,16 @@ function validateReleaseNotes(value, config, errors) {
     errors.push("'releaseNotes' must be an object");
     return;
   }
-  const knownReleaseNotesFields = /* @__PURE__ */ new Set(["shouldInjectIntoReadme", "shouldCreateGithubRelease"]);
+  const knownReleaseNotesFields = /* @__PURE__ */ new Set(["shouldInjectIntoReadme"]);
   for (const key of Object.keys(value)) {
     if (!knownReleaseNotesFields.has(key)) {
-      errors.push(`releaseNotes: unknown field '${key}'`);
+      if (key === "shouldCreateGithubRelease") {
+        errors.push(
+          "releaseNotes.shouldCreateGithubRelease is no longer supported. Adoption is now signaled by installing the create-github-release workflow. Remove this field from your config; see README for the updated workflow."
+        );
+      } else {
+        errors.push(`releaseNotes: unknown field '${key}'`);
+      }
     }
   }
   const result = {};
@@ -100,57 +101,199 @@ function validateReleaseNotes(value, config, errors) {
       errors.push("releaseNotes.shouldInjectIntoReadme: must be a boolean");
     }
   }
-  if (value.shouldCreateGithubRelease !== void 0) {
-    if (typeof value.shouldCreateGithubRelease === "boolean") {
-      result.shouldCreateGithubRelease = value.shouldCreateGithubRelease;
-    } else {
-      errors.push("releaseNotes.shouldCreateGithubRelease: must be a boolean");
-    }
-  }
   config.releaseNotes = result;
 }
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function validateComponents(value, config, errors) {
+function validateWorkspaces(value, config, errors) {
   if (value === void 0) return;
   if (!Array.isArray(value)) {
-    errors.push("'components' must be an array");
+    errors.push("'workspaces' must be an array");
     return;
   }
-  const components = [];
-  const knownComponentFields = /* @__PURE__ */ new Set(["dir", "shouldExclude"]);
+  const workspaces = [];
+  const knownWorkspaceFields = /* @__PURE__ */ new Set(["dir", "shouldExclude", "legacyIdentities"]);
   for (const [i, entry] of value.entries()) {
     if (!isRecord(entry)) {
-      errors.push(`components[${i}]: must be an object`);
+      errors.push(`workspaces[${i}]: must be an object`);
       continue;
     }
     if (typeof entry.dir !== "string" || entry.dir === "") {
-      errors.push(`components[${i}]: 'dir' is required`);
+      errors.push(`workspaces[${i}]: 'dir' is required`);
       continue;
     }
     for (const key of Object.keys(entry)) {
-      if (!knownComponentFields.has(key)) {
+      if (!knownWorkspaceFields.has(key)) {
         if (key === "tagPrefix") {
           errors.push(
-            `components[${i}]: 'tagPrefix' is no longer supported; remove it to use the default '${entry.dir}-v'`
+            `workspaces[${i}]: 'tagPrefix' is no longer supported; remove it to use the default '${entry.dir}-v'`
+          );
+        } else if (key === "legacyTagPrefixes") {
+          errors.push(
+            `workspaces[${i}]: 'legacyTagPrefixes' is no longer supported; use 'legacyIdentities: [{ name, tagPrefix }, ...]' instead`
           );
         } else {
-          errors.push(`components[${i}]: unknown field '${key}'`);
+          errors.push(`workspaces[${i}]: unknown field '${key}'`);
         }
       }
     }
-    const component = { dir: entry.dir };
+    const workspace = { dir: entry.dir };
     if (entry.shouldExclude !== void 0) {
       if (typeof entry.shouldExclude === "boolean") {
-        component.shouldExclude = entry.shouldExclude;
+        workspace.shouldExclude = entry.shouldExclude;
       } else {
-        errors.push(`components[${i}]: 'shouldExclude' must be a boolean`);
+        errors.push(`workspaces[${i}]: 'shouldExclude' must be a boolean`);
+      }
+    }
+    if (entry.legacyIdentities !== void 0) {
+      const identities = validateLegacyIdentities(entry.legacyIdentities, i, errors);
+      if (identities !== void 0) {
+        workspace.legacyIdentities = identities;
+      }
+    }
+    workspaces.push(workspace);
+  }
+  config.workspaces = workspaces;
+}
+function validateLegacyIdentities(value, workspaceIndex, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`workspaces[${workspaceIndex}]: 'legacyIdentities' must be an array`);
+    return void 0;
+  }
+  const knownIdentityFields = /* @__PURE__ */ new Set(["name", "tagPrefix"]);
+  const identities = [];
+  const seenTuples = /* @__PURE__ */ new Set();
+  for (const [entryIndex, entry] of value.entries()) {
+    if (!isRecord(entry)) {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: must be an object`);
+      continue;
+    }
+    let entryValid = true;
+    for (const key2 of Object.keys(entry)) {
+      if (!knownIdentityFields.has(key2)) {
+        errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: unknown field '${key2}'`);
+        entryValid = false;
+      }
+    }
+    const { name, tagPrefix } = entry;
+    if (typeof name !== "string") {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].name: must be a string`);
+      entryValid = false;
+    } else if (name === "") {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].name: must be a non-empty string`);
+      entryValid = false;
+    }
+    if (typeof tagPrefix !== "string") {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].tagPrefix: must be a string`);
+      entryValid = false;
+    } else if (tagPrefix === "") {
+      errors.push(
+        `workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].tagPrefix: must be a non-empty string`
+      );
+      entryValid = false;
+    }
+    if (!entryValid || typeof name !== "string" || typeof tagPrefix !== "string") {
+      continue;
+    }
+    const key = `${name}\0${tagPrefix}`;
+    if (seenTuples.has(key)) {
+      errors.push(
+        `workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: duplicate identity (name='${name}', tagPrefix='${tagPrefix}')`
+      );
+      continue;
+    }
+    seenTuples.add(key);
+    identities.push({ name, tagPrefix });
+  }
+  return identities;
+}
+function validateRetiredPackages(value, config, errors) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    errors.push("'retiredPackages' must be an array");
+    return;
+  }
+  const validEntries = [];
+  const seenTuples = /* @__PURE__ */ new Set();
+  for (const [i, entry] of value.entries()) {
+    const retired = validateRetiredPackageEntry(entry, i, errors);
+    if (retired === void 0) continue;
+    const key = `${retired.name}\0${retired.tagPrefix}`;
+    if (seenTuples.has(key)) {
+      errors.push(
+        `retiredPackages[${i}]: duplicate package (name='${retired.name}', tagPrefix='${retired.tagPrefix}')`
+      );
+      continue;
+    }
+    seenTuples.add(key);
+    validEntries.push({ entry: retired, rawIndex: i });
+  }
+  detectRetiredVsLegacyCollisions(validEntries, config, errors);
+  config.retiredPackages = validEntries.map(({ entry }) => entry);
+}
+function validateRetiredPackageEntry(entry, i, errors) {
+  if (!isRecord(entry)) {
+    errors.push(`retiredPackages[${i}]: must be an object`);
+    return void 0;
+  }
+  const knownRetiredFields = /* @__PURE__ */ new Set(["name", "tagPrefix", "successor"]);
+  let entryValid = true;
+  for (const key of Object.keys(entry)) {
+    if (!knownRetiredFields.has(key)) {
+      errors.push(`retiredPackages[${i}]: unknown field '${key}'`);
+      entryValid = false;
+    }
+  }
+  const { name, tagPrefix, successor } = entry;
+  if (!validateNonEmptyString(name, `retiredPackages[${i}].name`, errors)) {
+    entryValid = false;
+  }
+  if (!validateNonEmptyString(tagPrefix, `retiredPackages[${i}].tagPrefix`, errors)) {
+    entryValid = false;
+  }
+  if (successor !== void 0 && !validateNonEmptyString(successor, `retiredPackages[${i}].successor`, errors)) {
+    entryValid = false;
+  }
+  if (!entryValid || typeof name !== "string" || typeof tagPrefix !== "string") {
+    return void 0;
+  }
+  const retired = { name, tagPrefix };
+  if (typeof successor === "string" && successor !== "") {
+    retired.successor = successor;
+  }
+  return retired;
+}
+function detectRetiredVsLegacyCollisions(retiredPackages, config, errors) {
+  if (config.workspaces === void 0) return;
+  const legacyPrefixToWorkspace = /* @__PURE__ */ new Map();
+  for (const workspace of config.workspaces) {
+    if (workspace.legacyIdentities === void 0) continue;
+    for (const identity of workspace.legacyIdentities) {
+      if (!legacyPrefixToWorkspace.has(identity.tagPrefix)) {
+        legacyPrefixToWorkspace.set(identity.tagPrefix, workspace.dir);
       }
     }
-    components.push(component);
   }
-  config.components = components;
+  for (const { entry: retired, rawIndex } of retiredPackages) {
+    const collidingDir = legacyPrefixToWorkspace.get(retired.tagPrefix);
+    if (collidingDir !== void 0) {
+      errors.push(
+        `retiredPackages[${rawIndex}]: tagPrefix '${retired.tagPrefix}' collides with a declared legacyIdentities[].tagPrefix on workspace '${collidingDir}'`
+      );
+    }
+  }
+}
+function validateNonEmptyString(value, fieldPath, errors) {
+  if (typeof value !== "string") {
+    errors.push(`${fieldPath}: must be a string`);
+    return false;
+  }
+  if (value === "") {
+    errors.push(`${fieldPath}: must be a non-empty string`);
+    return false;
+  }
+  return true;
 }
 function validateVersionPatterns(value, config, errors) {
   if (value === void 0) return;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.8.0";
+export declare const VERSION = "5.0.0";

package/dist/esm/version.js

@@ -1,4 +1,4 @@
-const VERSION = "4.8.0";
+const VERSION = "5.0.0";
 export {
   VERSION
 };

package/dist/esm/writeReleaseNotesPreviews.d.ts

@@ -0,0 +1,18 @@
+export interface WriteReleaseNotesPreviewsOptions {
+    workspacePath: string;
+    tag: string;
+    changelogJsonPath: string;
+    sectionOrder: string[];
+    dryRun: boolean;
+}
+export interface PreviewFileResult {
+    filePath: string;
+    outcome: 'created' | 'overwritten' | 'skipped-no-readme' | 'failed' | 'dry-run';
+    error?: string;
+}
+export interface WriteReleaseNotesPreviewsResult {
+    injectedReadme?: PreviewFileResult;
+    releaseNotes?: PreviewFileResult;
+    renderSkipped: boolean;
+}
+export declare function writeReleaseNotesPreviews(options: WriteReleaseNotesPreviewsOptions): WriteReleaseNotesPreviewsResult;

package/dist/esm/writeReleaseNotesPreviews.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { writeFileWithCheck } from "@williamthorsen/nmr-core";
+import { extractVersion } from "./changelogJsonUtils.js";
+import { dim } from "./format.js";
+import { renderInjectedReadme } from "./injectReleaseNotesIntoReadme.js";
+function writeReleaseNotesPreviews(options) {
+  const { workspacePath, tag, changelogJsonPath, sectionOrder, dryRun } = options;
+  const version = extractVersion(tag);
+  const readmePath = path.join(workspacePath, "README.md");
+  let readmeExists = existsSync(readmePath);
+  let readmeUnreadable = false;
+  let readmeContent = "";
+  if (readmeExists) {
+    try {
+      readmeContent = readFileSync(readmePath, "utf8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Warning: failed to read ${readmePath}: ${message}; skipping injected-README preview`);
+      readmeExists = false;
+      readmeUnreadable = true;
+    }
+  }
+  const rendered = renderInjectedReadme(readmeContent, changelogJsonPath, tag, sectionOrder);
+  if (rendered === void 0) {
+    return { renderSkipped: true };
+  }
+  const docsDir = path.join(workspacePath, "docs");
+  const readmePreviewPath = path.join(docsDir, `README.v${version}.md`);
+  const releaseNotesPreviewPath = path.join(docsDir, `RELEASE_NOTES.v${version}.md`);
+  let injectedReadme;
+  if (readmeExists) {
+    injectedReadme = writePreviewFile(readmePreviewPath, rendered.injectedReadme, dryRun);
+  } else {
+    if (!readmeUnreadable) {
+      console.warn(
+        `Warning: ${readmePath} not found; skipping injected-README preview but still writing standalone release notes`
+      );
+    }
+    injectedReadme = { filePath: readmePreviewPath, outcome: "skipped-no-readme" };
+  }
+  const releaseNotesContent = rendered.releaseNotesMarkdown.endsWith("\n") ? rendered.releaseNotesMarkdown : `${rendered.releaseNotesMarkdown}
+`;
+  const releaseNotes = writePreviewFile(releaseNotesPreviewPath, releaseNotesContent, dryRun);
+  return { injectedReadme, releaseNotes, renderSkipped: false };
+}
+function writePreviewFile(filePath, content, dryRun) {
+  if (dryRun) {
+    console.info(dim(`  [dry-run] Would write ${filePath}`));
+    return { filePath, outcome: "dry-run" };
+  }
+  const result = writeFileWithCheck(filePath, content, { dryRun: false, overwrite: true });
+  if (result.outcome === "failed") {
+    console.error(`Error writing ${filePath}: ${result.error ?? "unknown error"}`);
+    return { filePath, outcome: "failed", ...result.error === void 0 ? {} : { error: result.error } };
+  }
+  if (result.outcome === "created" || result.outcome === "overwritten") {
+    console.info(dim(`  Wrote ${filePath}`));
+    return { filePath, outcome: result.outcome };
+  }
+  return { filePath, outcome: "failed", error: `unexpected outcome: ${result.outcome}` };
+}
+export {
+  writeReleaseNotesPreviews
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/release-kit",
-  "version": "4.8.0",
+  "version": "5.0.0",
   "description": "Version-bumping and changelog-generation toolkit for release workflows",
   "keywords": [],
   "homepage": "https://github.com/williamthorsen/node-monorepo-tools/tree/main/packages/release-kit#readme",
@@ -35,7 +35,7 @@
     "jiti": "2.6.1",
     "js-yaml": "4.1.1",
     "json-stringify-pretty-compact": "4.0.0",
-    "@williamthorsen/node-monorepo-core": "0.2.7"
+    "@williamthorsen/nmr-core": "0.3.0"
   },
   "devDependencies": {
     "@types/js-yaml": "4.0.9",

package/dist/esm/component.d.ts

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

package/dist/esm/component.js

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

package/dist/esm/findPackageRoot.d.ts

@@ -1 +0,0 @@
-export declare function findPackageRoot(fromUrl: string): string;

package/dist/esm/findPackageRoot.js

@@ -1,17 +0,0 @@
-import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-function findPackageRoot(fromUrl) {
-  let dir = dirname(fileURLToPath(fromUrl));
-  while (!existsSync(resolve(dir, "package.json"))) {
-    const parent = dirname(dir);
-    if (parent === dir) {
-      throw new Error("Could not find package root from " + fromUrl);
-    }
-    dir = parent;
-  }
-  return dir;
-}
-export {
-  findPackageRoot
-};

package/dist/esm/githubReleaseCommand.d.ts

@@ -1 +0,0 @@
-export declare function githubReleaseCommand(argv: string[]): Promise<void>;

package/dist/esm/githubReleaseCommand.js

@@ -1,35 +0,0 @@
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
-import { createGithubReleases } from "./createGithubRelease.js";
-import { resolveCommandTags } from "./resolveCommandTags.js";
-import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
-const githubReleaseFlagSchema = {
-  dryRun: { long: "--dry-run", type: "boolean" },
-  only: { long: "--only", type: "string" }
-};
-async function githubReleaseCommand(argv) {
-  let parsed;
-  try {
-    parsed = parseArgs(argv, githubReleaseFlagSchema);
-  } catch (error) {
-    console.error(`Error: ${translateParseError(error)}`);
-    process.exit(1);
-  }
-  const { dryRun } = parsed.flags;
-  const only = parsed.flags.only?.split(",");
-  const resolvedTags = await resolveCommandTags(only);
-  const { releaseNotes, changelogJsonOutputPath } = await resolveReleaseNotesConfig();
-  try {
-    createGithubReleases(
-      resolvedTags,
-      { ...releaseNotes, shouldCreateGithubRelease: true },
-      changelogJsonOutputPath,
-      dryRun
-    );
-  } catch (error) {
-    console.error(`Error creating GitHub Releases: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
-}
-export {
-  githubReleaseCommand
-};