@williamthorsen/release-kit 5.0.0 → 5.2.0

package/dist/esm/bin/release-kit.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
+import { parseArgs, readPackageVersion, translateParseError } from "@williamthorsen/nmr-core";
+import { checkWorkTypesDrift } from "../checkWorkTypesDrift.js";
 import { commitCommand } from "../commitCommand.js";
 import { createGithubReleaseCommand } from "../createGithubReleaseCommand.js";
 import { initCommand } from "../init/initCommand.js";
@@ -10,8 +11,9 @@ import { showTagPrefixesCommand } from "../showTagPrefixesCommand.js";
 import { generateCommand } from "../sync-labels/generateCommand.js";
 import { syncLabelsInitCommand } from "../sync-labels/initCommand.js";
 import { syncLabelsCommand } from "../sync-labels/syncCommand.js";
+import { syncWorkTypes } from "../syncWorkTypes.js";
 import { tagCommand } from "../tagCommand.js";
-import { VERSION } from "../version.js";
+const VERSION = readPackageVersion(import.meta.url);
 function showUsage() {
   console.info(`
 Usage: release-kit <command> [options]
@@ -26,6 +28,7 @@ Commands:
   show-tag-prefixes  Show derived and declared legacy tag prefixes per workspace
   init             Initialize release-kit in the current repository
   sync-labels      Manage GitHub label synchronization
+  work-types       Check for or sync work-type taxonomy drift against the upstream canonical
 
 Options:
   --dry-run     Preview changes without writing files
@@ -171,6 +174,49 @@ legacy tag prefixes. Surfaces any release-shaped tags whose prefix is neither a
 derived prefix nor declared in \`legacyIdentities\`, with a copy-pasteable
 config snippet.
 
+Options:
+  --help, -h    Show this help message
+`);
+}
+function showWorkTypesHelp() {
+  console.info(`
+Usage: release-kit work-types <subcommand>
+
+Manage the canonical work-types taxonomy used by changelog and release-notes generation.
+
+Subcommands:
+  check         Compare the local work-types.json against the upstream codeassembly canonical
+  sync          Overwrite the local work-types.json with the upstream contents
+
+Exit codes (check):
+  0    Match (or upstream missing \u2014 transitional warning printed)
+  1    Drift detected
+  2    Network error
+  3    Schema mismatch
+
+Options:
+  --help, -h    Show this help message
+`);
+}
+function showWorkTypesCheckHelp() {
+  console.info(`
+Usage: release-kit work-types check
+
+Compare the local work-types.json against the upstream codeassembly canonical and report
+drift. Exit 0 on match, 1 on drift, 0 + warning when upstream is missing (transitional),
+2 on network error, 3 on schema mismatch.
+
+Options:
+  --help, -h    Show this help message
+`);
+}
+function showWorkTypesSyncHelp() {
+  console.info(`
+Usage: release-kit work-types sync
+
+Fetch the upstream work-types.json, validate its top-level shape, and overwrite the local
+copy with the upstream content (formatted with 2-space indent + trailing newline).
+
 Options:
   --help, -h    Show this help message
 `);
@@ -179,11 +225,13 @@ function showPublishHelp() {
   console.info(`
 Usage: release-kit publish [options]
 
-Publish packages that have release tags on HEAD.
+Publish packages that have release tags on HEAD. Operates only on workspaces where
+package.json#private is absent or false. Without --tags, unpublishable workspaces are
+silently filtered out. With --tags, naming an unpublishable tag is an error.
 
 Options:
   --dry-run              Preview without publishing
-  --no-git-checks        Skip git checks (pnpm only)
+  --no-git-checks        Skip the clean-working-tree check
   --tags=tag1,tag2       Only publish the named tags (comma-separated, full tag names)
   --provenance           Generate provenance statement (requires OIDC, not supported by classic yarn)
   --help, -h             Show this help message
@@ -341,6 +389,51 @@ if (command === "sync-labels") {
   showSyncLabelsHelp();
   process.exit(1);
 }
+if (command === "work-types") {
+  const subcommand = flags[0];
+  const subflags = flags.slice(1);
+  if (subcommand === "--help" || subcommand === "-h" || subcommand === void 0) {
+    showWorkTypesHelp();
+    process.exit(0);
+  }
+  if (subcommand === "check") {
+    if (subflags.some((f) => f === "--help" || f === "-h")) {
+      showWorkTypesCheckHelp();
+      process.exit(0);
+    }
+    if (subflags.length > 0) {
+      console.error(`Error: Unknown option: ${subflags[0]}`);
+      process.exit(1);
+    }
+    const result = await checkWorkTypesDrift();
+    if (result.exitCode === 0) {
+      console.info(result.message);
+    } else {
+      console.error(result.message);
+    }
+    process.exit(result.exitCode);
+  }
+  if (subcommand === "sync") {
+    if (subflags.some((f) => f === "--help" || f === "-h")) {
+      showWorkTypesSyncHelp();
+      process.exit(0);
+    }
+    if (subflags.length > 0) {
+      console.error(`Error: Unknown option: ${subflags[0]}`);
+      process.exit(1);
+    }
+    const result = await syncWorkTypes();
+    if (result.exitCode === 0) {
+      console.info(result.message);
+    } else {
+      console.error(result.message);
+    }
+    process.exit(result.exitCode);
+  }
+  console.error(`Error: Unknown subcommand: ${subcommand}`);
+  showWorkTypesHelp();
+  process.exit(1);
+}
 console.error(`Error: Unknown command: ${command}`);
 showUsage();
 process.exit(1);

package/dist/esm/buildChangelogEntries.d.ts

@@ -0,0 +1,4 @@
+import type { GenerateChangelogOptions } from './generateChangelogs.ts';
+import type { ChangelogEntry, ReleaseConfig } from './types.ts';
+export declare function stripGroupDecorations(group: string): string;
+export declare function buildChangelogEntries(config: Pick<ReleaseConfig, 'cliffConfigPath' | 'changelogJson'>, tag: string, options?: GenerateChangelogOptions): ChangelogEntry[];

package/dist/esm/buildChangelogEntries.js

@@ -0,0 +1,173 @@
+import { extractVersion } from "./changelogJsonUtils.js";
+import { DEFAULT_WORK_TYPES } from "./defaults.js";
+import { COMMIT_PREPROCESSOR_PATTERNS } from "./parseCommitMessage.js";
+import { resolveCliffConfigPath } from "./resolveCliffConfigPath.js";
+import { runGitCliff } from "./runGitCliff.js";
+import { stripEmojiPrefix } from "./stripEmojiPrefix.js";
+import { isRecord, isUnknownArray } from "./typeGuards.js";
+const HTML_COMMENT_PREFIX_PATTERN = /^<!--[^>]*-->/;
+const CANONICAL_SECTION_ORDER = new Map(
+  Object.values(DEFAULT_WORK_TYPES).map((config, index) => [stripGroupDecorations(config.header), index])
+);
+function canonicalSectionPriority(title) {
+  const index = CANONICAL_SECTION_ORDER.get(stripGroupDecorations(title));
+  return index ?? Number.POSITIVE_INFINITY;
+}
+function stripGroupDecorations(group) {
+  return stripEmojiPrefix(group.replace(HTML_COMMENT_PREFIX_PATTERN, ""));
+}
+function buildChangelogEntries(config, tag, options) {
+  const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
+  const cliffArgs = ["--context", "--tag", tag];
+  if (options?.tagPattern !== void 0) {
+    cliffArgs.push("--tag-pattern", options.tagPattern);
+  }
+  for (const includePath of options?.includePaths ?? []) {
+    cliffArgs.push("--include-path", includePath);
+  }
+  try {
+    const contextJson = runGitCliff(resolvedConfigPath, cliffArgs, ["pipe", "pipe", "inherit"]);
+    const releases = parseCliffContext(contextJson);
+    const devOnlySections = new Set(config.changelogJson.devOnlySections);
+    return transformReleases(releases, devOnlySections);
+  } catch (error) {
+    throw new Error(
+      `Failed to build changelog entries for tag ${tag}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function parseCliffContext(json) {
+  const parsed = JSON.parse(json);
+  if (!isUnknownArray(parsed)) {
+    throw new TypeError("Expected git-cliff --context output to be an array");
+  }
+  return parsed.map(toCliffContextRelease);
+}
+function toCliffContextRelease(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const release = {};
+  if (typeof value.version === "string") {
+    release.version = value.version;
+  }
+  if (typeof value.timestamp === "number") {
+    release.timestamp = value.timestamp;
+  }
+  if (isUnknownArray(value.commits)) {
+    release.commits = value.commits.map(toCliffContextCommit);
+  }
+  return release;
+}
+function toCliffContextCommit(value) {
+  if (!isRecord(value)) {
+    return { message: "" };
+  }
+  const commit = {
+    message: typeof value.message === "string" ? value.message : ""
+  };
+  if (typeof value.group === "string") {
+    commit.group = value.group;
+  }
+  return commit;
+}
+function transformReleases(releases, devOnlySections) {
+  const entries = [];
+  const devOnlyNormalised = new Set([...devOnlySections].map(stripGroupDecorations));
+  for (const release of releases) {
+    if (release.version === void 0) {
+      continue;
+    }
+    const version = extractVersion(release.version);
+    const date = release.timestamp !== void 0 ? new Date(release.timestamp * 1e3).toISOString().slice(0, 10) : "unreleased";
+    const sectionMap = /* @__PURE__ */ new Map();
+    for (const commit of release.commits ?? []) {
+      const group = stripCommentPrefix(commit.group ?? "Other");
+      const description = extractDescription(commit.message);
+      const body = extractBody(commit.message);
+      const breaking = subjectHasBreakingMarker(commit.message);
+      let items = sectionMap.get(group);
+      if (items === void 0) {
+        items = [];
+        sectionMap.set(group, items);
+      }
+      const item = { description };
+      if (body !== void 0) {
+        item.body = body;
+      }
+      if (breaking) {
+        item.breaking = true;
+      }
+      items.push(item);
+    }
+    const sections = [];
+    for (const [title, items] of sectionMap) {
+      if (items.length === 0) {
+        continue;
+      }
+      sections.push({
+        title,
+        audience: devOnlyNormalised.has(stripGroupDecorations(title)) ? "dev" : "all",
+        items
+      });
+    }
+    sections.sort((a, b) => canonicalSectionPriority(a.title) - canonicalSectionPriority(b.title));
+    if (sections.length > 0) {
+      entries.push({ version, date, sections });
+    }
+  }
+  return entries;
+}
+function stripCommentPrefix(group) {
+  return group.replace(HTML_COMMENT_PREFIX_PATTERN, "");
+}
+function subjectHasBreakingMarker(message) {
+  let subject = message.split("\n", 1)[0] ?? "";
+  for (const pattern of COMMIT_PREPROCESSOR_PATTERNS) {
+    subject = subject.replace(pattern, "");
+  }
+  return /^(?:[^|]+\|)?\w+(?:\([^)]+\))?!:/.test(subject);
+}
+function extractDescription(message) {
+  const firstLine = message.split("\n")[0] ?? message;
+  const afterColon = firstLine.split(": ").slice(1).join(": ");
+  if (afterColon.length > 0) {
+    return afterColon.charAt(0).toUpperCase() + afterColon.slice(1);
+  }
+  return firstLine;
+}
+const TRAILER_PATTERNS = [
+  /^Signed-off-by:/i,
+  /^Co-authored-by:/i,
+  /^(Closes|Fixes|Resolves)\s+#\d+\s*$/i,
+  /^https?:\/\/\S+\/pull\/\d+\/?\s*$/
+];
+function extractBody(message) {
+  const lines = message.split("\n").slice(1);
+  let start = 0;
+  while (start < lines.length && (lines[start] ?? "").trim() === "") {
+    start += 1;
+  }
+  let end = lines.length;
+  while (end > start) {
+    const line = lines[end - 1] ?? "";
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      end -= 1;
+      continue;
+    }
+    if (TRAILER_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+      end -= 1;
+      continue;
+    }
+    break;
+  }
+  if (end <= start) {
+    return void 0;
+  }
+  return lines.slice(start, end).join("\n").trim();
+}
+export {
+  buildChangelogEntries,
+  stripGroupDecorations
+};

package/dist/esm/buildDependencyGraph.d.ts

@@ -3,5 +3,6 @@ export interface DependencyGraph {
     packageNameToDir: Map<string, string>;
     dirToPackageName: Map<string, string>;
     dependentsOf: Map<string, WorkspaceConfig[]>;
+    dependenciesOf: Map<string, Set<string>>;
 }
 export declare function buildDependencyGraph(workspaces: readonly WorkspaceConfig[]): DependencyGraph;

package/dist/esm/buildDependencyGraph.js

@@ -6,6 +6,7 @@ function buildDependencyGraph(workspaces) {
   const packageNameToDir = /* @__PURE__ */ new Map();
   const dirToPackageName = /* @__PURE__ */ new Map();
   const dependentsOf = /* @__PURE__ */ new Map();
+  const dependenciesOf = /* @__PURE__ */ new Map();
   const workspacePackages = /* @__PURE__ */ new Map();
   for (const workspace of workspaces) {
     const primaryPackageFile = workspace.packageFiles[0];
@@ -32,9 +33,15 @@ function buildDependencyGraph(workspaces) {
       } else {
         existing.push(workspace);
       }
+      const forward = dependenciesOf.get(workspace.dir);
+      if (forward === void 0) {
+        dependenciesOf.set(workspace.dir, /* @__PURE__ */ new Set([depName]));
+      } else {
+        forward.add(depName);
+      }
     }
   }
-  return { packageNameToDir, dirToPackageName, dependentsOf };
+  return { packageNameToDir, dirToPackageName, dependentsOf, dependenciesOf };
 }
 function readPackageJsonSubset(filePath) {
   let content;

package/dist/esm/buildReleaseSummary.js

@@ -2,7 +2,7 @@ import { stripScope } from "./stripScope.js";
 function buildReleaseSummary(result) {
   const sections = [];
   for (const workspace of result.workspaces) {
-    if (workspace.status !== "released" || workspace.tag === void 0) {
+    if (workspace.status !== "released") {
       continue;
     }
     const commits = workspace.commits;
@@ -15,6 +15,14 @@ function buildReleaseSummary(result) {
     }
     sections.push(lines.join("\n"));
   }
+  const project = result.project;
+  if (project !== void 0 && project.status === "released" && project.commits.length > 0) {
+    const lines = [project.tag];
+    for (const commit of project.commits) {
+      lines.push(`- ${stripScope(commit.message)}`);
+    }
+    sections.push(lines.join("\n"));
+  }
   return sections.join("\n\n");
 }
 export {

package/dist/esm/buildSyntheticChangelogEntry.d.ts

@@ -0,0 +1,5 @@
+import type { ChangelogEntry } from './types.ts';
+export declare function buildSyntheticChangelogEntry(propagatedFrom: ReadonlyArray<{
+    packageName: string;
+    newVersion: string;
+}>, version: string, date: string): ChangelogEntry;

package/dist/esm/buildSyntheticChangelogEntry.js

@@ -0,0 +1,13 @@
+function buildSyntheticChangelogEntry(propagatedFrom, version, date) {
+  const items = propagatedFrom.map((dep) => ({
+    description: `Bumped \`${dep.packageName}\` to ${dep.newVersion}`
+  }));
+  return {
+    version,
+    date,
+    sections: [{ title: "Dependency updates", audience: "dev", items }]
+  };
+}
+export {
+  buildSyntheticChangelogEntry
+};

package/dist/esm/changelogJsonFile.d.ts

@@ -0,0 +1,4 @@
+import type { ChangelogEntry, ReleaseConfig } from './types.ts';
+export declare function resolveChangelogJsonPath(config: Pick<ReleaseConfig, 'changelogJson'>, changelogPath: string): string;
+export declare function writeChangelogJson(filePath: string, entries: ChangelogEntry[]): string;
+export declare function upsertChangelogJson(filePath: string, entries: ChangelogEntry[]): string;

package/dist/esm/changelogJsonFile.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import stringify from "json-stringify-pretty-compact";
+import semver from "semver";
+import { isChangelogEntry } from "./changelogJsonUtils.js";
+import { isUnknownArray } from "./typeGuards.js";
+function resolveChangelogJsonPath(config, changelogPath) {
+  return join(changelogPath, config.changelogJson.outputPath);
+}
+function writeChangelogJson(filePath, entries) {
+  const sorted = sortNewestFirst(entries);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, stringify(sorted, { maxLength: 100 }) + "\n", "utf8");
+  return filePath;
+}
+function upsertChangelogJson(filePath, entries) {
+  const existing = readExistingEntries(filePath);
+  const merged = mergeEntries(entries, existing);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, stringify(merged, { maxLength: 100 }) + "\n", "utf8");
+  return filePath;
+}
+function sortNewestFirst(entries) {
+  return [...entries].sort((a, b) => compareVersionsDescending(a.version, b.version));
+}
+function readExistingEntries(filePath) {
+  if (!existsSync(filePath)) {
+    return [];
+  }
+  try {
+    const content = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!isUnknownArray(parsed)) {
+      return [];
+    }
+    return parsed.filter(isChangelogEntry);
+  } catch (error) {
+    console.warn(
+      `Warning: could not parse existing ${filePath}: ${error instanceof Error ? error.message : String(error)}; treating as empty`
+    );
+    return [];
+  }
+}
+function mergeEntries(newEntries, existingEntries) {
+  const versionMap = /* @__PURE__ */ new Map();
+  for (const entry of existingEntries) {
+    versionMap.set(entry.version, entry);
+  }
+  for (const entry of newEntries) {
+    versionMap.set(entry.version, entry);
+  }
+  return sortNewestFirst(versionMap.values());
+}
+function compareVersionsDescending(a, b) {
+  const aValid = semver.valid(a);
+  const bValid = semver.valid(b);
+  if (aValid && bValid) return semver.rcompare(aValid, bValid);
+  if (aValid) return -1;
+  if (bValid) return 1;
+  if (a > b) return -1;
+  if (a < b) return 1;
+  return 0;
+}
+export {
+  resolveChangelogJsonPath,
+  upsertChangelogJson,
+  writeChangelogJson
+};

package/dist/esm/checkWorkTypesDrift.d.ts

@@ -0,0 +1,11 @@
+export declare const UPSTREAM_WORK_TYPES_URL = "https://raw.githubusercontent.com/williamthorsen/codeassembly/main/packages/agents/content/skills/_data/work-types.json";
+export interface DriftCheckResult {
+    exitCode: 0 | 1 | 2 | 3;
+    message: string;
+}
+export interface CheckWorkTypesDriftDependencies {
+    localPath?: string;
+    fetch?: typeof globalThis.fetch;
+    upstreamUrl?: string;
+}
+export declare function checkWorkTypesDrift(dependencies?: CheckWorkTypesDriftDependencies): Promise<DriftCheckResult>;

package/dist/esm/checkWorkTypesDrift.js

@@ -0,0 +1,110 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { errorMessage, hasExpectedTopLevelShape } from "./workTypesUtils.js";
+const UPSTREAM_WORK_TYPES_URL = "https://raw.githubusercontent.com/williamthorsen/codeassembly/main/packages/agents/content/skills/_data/work-types.json";
+function resolveDefaultLocalPath() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(moduleDir, "work-types.json");
+}
+async function checkWorkTypesDrift(dependencies = {}) {
+  const localPath = dependencies.localPath ?? resolveDefaultLocalPath();
+  const fetcher = dependencies.fetch ?? globalThis.fetch;
+  const url = dependencies.upstreamUrl ?? UPSTREAM_WORK_TYPES_URL;
+  const localContent = readFileSync(localPath, "utf8");
+  let localJson;
+  try {
+    localJson = JSON.parse(localContent);
+  } catch (error) {
+    return {
+      exitCode: 3,
+      message: `Local work-types.json is not valid JSON: ${errorMessage(error)}`
+    };
+  }
+  let response;
+  try {
+    response = await fetcher(url);
+  } catch (error) {
+    return {
+      exitCode: 2,
+      message: `Network error fetching upstream work-types.json: ${errorMessage(error)}`
+    };
+  }
+  if (response.status === 404) {
+    return {
+      exitCode: 0,
+      message: `Upstream work-types.json not yet published at ${url}; skipping drift check.`
+    };
+  }
+  if (!response.ok) {
+    return {
+      exitCode: 2,
+      message: `Failed to fetch upstream work-types.json: HTTP ${response.status} ${response.statusText}`
+    };
+  }
+  const upstreamText = await response.text();
+  let upstreamJson;
+  try {
+    upstreamJson = JSON.parse(upstreamText);
+  } catch (error) {
+    return {
+      exitCode: 3,
+      message: `Upstream work-types.json is not valid JSON: ${errorMessage(error)}`
+    };
+  }
+  if (!hasExpectedTopLevelShape(upstreamJson)) {
+    return {
+      exitCode: 3,
+      message: "Upstream work-types.json does not match the expected schema shape (missing `tiers` or `types`)."
+    };
+  }
+  const normalisedLocal = stripLocalOnlyFields(localJson);
+  if (deepEqual(normalisedLocal, upstreamJson)) {
+    return {
+      exitCode: 0,
+      message: "Local work-types.json matches upstream."
+    };
+  }
+  return {
+    exitCode: 1,
+    message: `Drift detected. Local and upstream work-types.json differ. Run \`nmr work-types:sync\` to update from upstream.
+Local:    ${localPath}
+Upstream: ${url}`
+  };
+}
+function stripLocalOnlyFields(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const record = { ...value };
+  delete record.$schema;
+  return record;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
+    const aRecord = { ...a };
+    const bRecord = { ...b };
+    const aKeys = Object.keys(aRecord);
+    const bKeys = Object.keys(bRecord);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!deepEqual(aRecord[key], bRecord[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+export {
+  UPSTREAM_WORK_TYPES_URL,
+  checkWorkTypesDrift
+};

package/dist/esm/collectPolicyViolations.d.ts

@@ -0,0 +1,6 @@
+import type { PolicyViolationHandler } from './parseCommitMessage.ts';
+import type { PolicyViolation } from './types.ts';
+export declare function createPolicyViolationCollector(): {
+    violations: PolicyViolation[];
+    onPolicyViolation: PolicyViolationHandler;
+};

package/dist/esm/collectPolicyViolations.js

@@ -0,0 +1,15 @@
+function createPolicyViolationCollector() {
+  const violations = [];
+  const onPolicyViolation = (commit, type, surface) => {
+    violations.push({
+      commitHash: commit.hash,
+      commitSubject: commit.message.split("\n", 1)[0] ?? "",
+      type,
+      surface
+    });
+  };
+  return { violations, onPolicyViolation };
+}
+export {
+  createPolicyViolationCollector
+};

package/dist/esm/createGithubRelease.d.ts

@@ -4,10 +4,20 @@ export interface CreateGithubReleaseOptions {
     dryRun: boolean;
     sectionOrder?: string[];
 }
-export declare function createGithubRelease(options: CreateGithubReleaseOptions): boolean;
+export type CreateReleaseSkipReason = 'no-entry' | 'no-audience-content' | 'empty-body';
+export type CreateReleaseResult = {
+    status: 'created';
+} | {
+    status: 'skipped';
+    reason: CreateReleaseSkipReason;
+};
+export declare function createGithubRelease(options: CreateGithubReleaseOptions): CreateReleaseResult;
 export interface CreateGithubReleasesOutcome {
     created: string[];
-    skipped: string[];
+    skipped: Array<{
+        tag: string;
+        reason: CreateReleaseSkipReason;
+    }>;
 }
 export declare function createGithubReleases(tags: Array<{
     tag: string;