@absolutejs/changelog 0.1.0

package/dist/cli.js

@@ -0,0 +1,1007 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { existsSync } from "fs";
+import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/entries.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { pathToFileURL } from "url";
+
+// src/types.ts
+var CHANGE_KINDS = [
+  "breaking",
+  "removed",
+  "added",
+  "changed",
+  "deprecated",
+  "fixed",
+  "security",
+  "internal"
+];
+var DISRUPTIVE_KINDS = ["breaking", "removed"];
+var CHANGELOG_CONTRACT = 1;
+var CHANGELOG_FILE = "changelog.json";
+var CHANGELOG_MARKDOWN = "CHANGELOG.md";
+var UNRELEASED_DIRECTORY = "changelog/unreleased";
+var isDisruptive = (change) => change.kind === "breaking" || change.kind === "removed";
+var isMechanical = (migration) => !("manual" in migration);
+
+// src/versioning.ts
+var OLDER = -1;
+var LAST = -1;
+var NEWER = 1;
+var VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u;
+var parseVersion = (version) => {
+  const found = VERSION.exec(version.trim());
+  if (!found)
+    return;
+  const [, major, minor, patch, prerelease] = found;
+  return {
+    prerelease: prerelease === undefined ? [] : prerelease.split("."),
+    release: [Number(major), Number(minor), Number(patch)]
+  };
+};
+var isNumeric = (value) => /^\d+$/u.test(value);
+var comparePrerelease = (left, right) => {
+  if (left.length === 0 || right.length === 0)
+    return right.length - left.length;
+  for (const [index, mine] of left.entries()) {
+    const theirs = right[index];
+    if (theirs === undefined)
+      return NEWER;
+    if (mine === theirs)
+      continue;
+    if (isNumeric(mine) && isNumeric(theirs))
+      return Number(mine) - Number(theirs);
+    if (isNumeric(mine))
+      return OLDER;
+    if (isNumeric(theirs))
+      return NEWER;
+    return mine < theirs ? OLDER : NEWER;
+  }
+  return left.length - right.length;
+};
+var compareVersions = (left, right) => {
+  const mine = parseVersion(left);
+  const theirs = parseVersion(right);
+  if (!mine || !theirs)
+    return 0;
+  for (const [index, part] of mine.release.entries()) {
+    const other = theirs.release[index] ?? 0;
+    if (part !== other)
+      return part - other;
+  }
+  return comparePrerelease(mine.prerelease, theirs.prerelease);
+};
+var isPrerelease = (version) => (parseVersion(version)?.prerelease.length ?? 0) > 0;
+var releaseKindFor = (changes) => {
+  if (changes.some(isDisruptive)) {
+    const major = "major";
+    return major;
+  }
+  const asked = changes.some((entry) => entry.kind === "added") ? "minor" : "patch";
+  return asked;
+};
+var bumpPrerelease = (parsed) => {
+  const { prerelease, release } = parsed;
+  const last = prerelease.at(LAST);
+  const counted = last !== undefined && isNumeric(last) ? [...prerelease.slice(0, LAST), String(Number(last) + 1)] : [...prerelease, "1"];
+  return `${release.join(".")}-${counted.join(".")}`;
+};
+var nextVersion = (input) => {
+  const parsed = parseVersion(input.current);
+  if (!parsed)
+    return;
+  const [major, minor, patch] = parsed.release;
+  const kind = input.asked ?? (parsed.prerelease.length > 0 ? "prerelease" : releaseKindFor(input.changes));
+  if (kind === "prerelease")
+    return parsed.prerelease.length > 0 ? bumpPrerelease(parsed) : `${major}.${minor}.${patch + 1}-${input.prereleaseIdentifier ?? "beta"}.1`;
+  if (parsed.prerelease.length > 0 && kind === "patch")
+    return `${major}.${minor}.${patch}`;
+  if (kind === "major")
+    return major === 0 ? `${major}.${minor + 1}.0` : `${major + 1}.0.0`;
+  return kind === "minor" ? `${major}.${minor + 1}.0` : `${major}.${minor}.${patch + 1}`;
+};
+
+// src/read.ts
+var isKind = (value) => typeof value === "string" && CHANGE_KINDS.some((known) => known === value);
+var isDisruptiveKind = (kind) => kind === "breaking" || kind === "removed";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isText = (value) => typeof value === "string" && value.trim().length > 0;
+var textList = (value) => Array.isArray(value) && value.length > 0 && value.every(isText) ? value : undefined;
+var readMigration = (value, where, problems) => {
+  if (!isRecord(value) || !isText(value.instruction)) {
+    problems.push(`${where}: migration needs an instruction`);
+    return;
+  }
+  const { instruction } = value;
+  const { rename } = value;
+  if (isRecord(rename) && isText(rename.from) && isText(rename.to))
+    return {
+      instruction,
+      rename: { from: rename.from, to: rename.to }
+    };
+  const { moved } = value;
+  if (isRecord(moved) && isText(moved.symbol) && isText(moved.from) && isText(moved.to))
+    return {
+      instruction,
+      moved: { from: moved.from, symbol: moved.symbol, to: moved.to }
+    };
+  const { resubpath } = value;
+  if (isRecord(resubpath) && isText(resubpath.from) && isText(resubpath.to))
+    return {
+      instruction,
+      resubpath: { from: resubpath.from, to: resubpath.to }
+    };
+  if (value.manual === true)
+    return { instruction, manual: true };
+  problems.push(`${where}: migration says neither rename, moved, resubpath nor manual`);
+  return;
+};
+var readChange = (value, where, problems) => {
+  if (!isRecord(value)) {
+    problems.push(`${where}: not an object`);
+    return;
+  }
+  const { kind } = value;
+  if (!isKind(kind)) {
+    problems.push(`${where}: unknown kind ${JSON.stringify(kind)}`);
+    return;
+  }
+  if (!isText(value.summary)) {
+    problems.push(`${where}: needs a summary`);
+    return;
+  }
+  const shared = {
+    ...isText(value.detail) ? { detail: value.detail } : {},
+    ...isText(value.reference) ? { reference: value.reference } : {},
+    summary: value.summary
+  };
+  const symbols = textList(value.symbols);
+  const [first, ...rest] = symbols ?? [];
+  if (kind === "breaking" || kind === "removed") {
+    const migration = readMigration(value.migration, where, problems);
+    if (first === undefined)
+      problems.push(`${where}: a ${kind} change must name symbols`);
+    if (!migration || first === undefined)
+      return;
+    const named = [first, ...rest];
+    const disruptive = {
+      ...shared,
+      kind,
+      migration,
+      symbols: named
+    };
+    return disruptive;
+  }
+  if (isDisruptiveKind(kind))
+    return;
+  const ordinary = {
+    ...shared,
+    kind,
+    ...symbols ? { symbols } : {}
+  };
+  return ordinary;
+};
+var readRelease = (value, where, problems) => {
+  if (!isRecord(value)) {
+    problems.push(`${where}: not an object`);
+    return;
+  }
+  if (!isText(value.version) || parseVersion(value.version) === undefined) {
+    problems.push(`${where}: version is not a version`);
+    return;
+  }
+  if (!isText(value.date)) {
+    problems.push(`${where}: needs a date`);
+    return;
+  }
+  const raw = value.changes;
+  if (!Array.isArray(raw) || raw.length === 0) {
+    problems.push(`${where}: a release with no changes is not a release`);
+    return;
+  }
+  const changes = raw.map((entry, index) => readChange(entry, `${where}.changes[${index}]`, problems)).filter((entry) => entry !== undefined);
+  if (changes.length !== raw.length)
+    return;
+  const [head, ...tail] = changes;
+  if (head === undefined)
+    return;
+  const release = {
+    changes: [head, ...tail],
+    date: value.date,
+    ...isText(value.note) ? { note: value.note } : {},
+    version: value.version
+  };
+  return release;
+};
+var validateChange = (value, where = "entry") => {
+  const problems = [];
+  const change = readChange(value, where, problems);
+  if (change === undefined) {
+    const failed = { problems };
+    return failed;
+  }
+  const read = { change };
+  return read;
+};
+var parseChangelog = (value) => {
+  const problems = [];
+  if (!isRecord(value))
+    return { problems: ["not an object"] };
+  if (!isText(value.name))
+    problems.push("needs a package name");
+  if (value.contract !== CHANGELOG_CONTRACT)
+    problems.push(`contract ${JSON.stringify(value.contract)} is not ${CHANGELOG_CONTRACT}`);
+  const raw = value.releases;
+  if (!Array.isArray(raw))
+    problems.push("releases is not a list");
+  const releases = (Array.isArray(raw) ? raw : []).map((entry, index) => readRelease(entry, `releases[${index}]`, problems)).filter((entry) => entry !== undefined);
+  if (problems.length > 0)
+    return { problems };
+  return {
+    changelog: {
+      contract: CHANGELOG_CONTRACT,
+      name: String(value.name),
+      releases: [...releases].sort((left, right) => compareVersions(right.version, left.version))
+    }
+  };
+};
+var releasesBetween = (changelog, from, upto) => [...changelog.releases].filter((release) => compareVersions(release.version, from) > 0 && compareVersions(release.version, upto) <= 0).sort((left, right) => compareVersions(left.version, right.version));
+var changesBetween = (changelog, from, upto) => releasesBetween(changelog, from, upto).flatMap((release) => release.changes.map((change) => {
+  const found = { change, version: release.version };
+  return found;
+}));
+var isDisruptiveAt = (found) => isDisruptive(found.change);
+var disruptiveBetween = (changelog, from, upto) => changesBetween(changelog, from, upto).filter(isDisruptiveAt);
+var mechanicalMigrations = (migrations) => migrations.filter((found) => isMechanical(found.migration));
+var migrationsBetween = (changelog, from, upto) => disruptiveBetween(changelog, from, upto).map(({ change, version }) => {
+  const found = {
+    migration: change.migration,
+    symbols: change.symbols,
+    version
+  };
+  return found;
+});
+var symbolsDisturbedBetween = (changelog, from, upto) => new Set(disruptiveBetween(changelog, from, upto).flatMap(({ change }) => change.symbols));
+
+// src/tarball.ts
+var TAR_BLOCK = 512;
+var NAME_LENGTH = 100;
+var SIZE_OFFSET = 124;
+var SIZE_LENGTH = 12;
+var TYPE_OFFSET = 156;
+var PREFIX_OFFSET = 345;
+var PREFIX_LENGTH = 155;
+var OCTAL = 8;
+var KIBIBYTE = 1024;
+var MEBIBYTE = KIBIBYTE * KIBIBYTE;
+var DEFAULT_FILE_MEBIBYTES = 4;
+var DEFAULT_TOTAL_MEBIBYTES = 64;
+var DEFAULT_FILE_BYTES = DEFAULT_FILE_MEBIBYTES * MEBIBYTE;
+var DEFAULT_TOTAL_BYTES = DEFAULT_TOTAL_MEBIBYTES * MEBIBYTE;
+var decoder = new TextDecoder;
+var cString = (bytes) => {
+  const end = bytes.indexOf(0);
+  return decoder.decode(end < 0 ? bytes : bytes.subarray(0, end)).trim();
+};
+var asText = (bytes) => decoder.decode(bytes);
+var readTar = (archive, keep, limits = {}) => {
+  const maxFile = limits.maxFileBytes ?? DEFAULT_FILE_BYTES;
+  const maxTotal = limits.maxTotalBytes ?? DEFAULT_TOTAL_BYTES;
+  const files = new Map;
+  let offset = 0;
+  let total = 0;
+  while (offset + TAR_BLOCK <= archive.length) {
+    const header = archive.subarray(offset, offset + TAR_BLOCK);
+    const name = cString(header.subarray(0, NAME_LENGTH));
+    if (name === "")
+      break;
+    const prefix = cString(header.subarray(PREFIX_OFFSET, PREFIX_OFFSET + PREFIX_LENGTH));
+    const size = Number.parseInt(cString(header.subarray(SIZE_OFFSET, SIZE_OFFSET + SIZE_LENGTH)), OCTAL);
+    if (!Number.isSafeInteger(size) || size < 0)
+      break;
+    const kind = String.fromCharCode(header[TYPE_OFFSET] ?? 0);
+    const start = offset + TAR_BLOCK;
+    const path = (prefix === "" ? name : `${prefix}/${name}`).replace(/^package\//u, "");
+    const plain = kind === "0" || kind === "\x00";
+    const wanted = plain && size <= maxFile && keep(path);
+    total += wanted ? size : 0;
+    if (total > maxTotal)
+      break;
+    if (wanted)
+      files.set(path, archive.subarray(start, start + size));
+    offset = start + Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+  }
+  return files;
+};
+
+// src/surface.ts
+var DECLARATION = /\bexport\s+(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(function|const|let|var|class|interface|type|enum|namespace)\s+([A-Za-z_$][\w$]*)/gu;
+var NAMED_EXPORT = /\bexport\s*\{([^}]*)\}/gu;
+var BODIED = new Set(["class", "interface", "enum", "namespace"]);
+var OPENS = new Set(["{", "(", "["]);
+var CLOSES = new Set(["}", ")", "]"]);
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+var LAST2 = -1;
+var NOWHERE = -1;
+var MEMBER = /([A-Za-z_$][\w$]*)\s*[?!]?\s*[:(<]/u;
+var isStub = (declaration) => declaration.startsWith("export {");
+var declarationEnd = (source, from, bodied) => {
+  let depth = 0;
+  for (let index = from;index < source.length; index += 1) {
+    const character = source[index] ?? "";
+    if (OPENS.has(character))
+      depth += 1;
+    else if (CLOSES.has(character))
+      depth -= 1;
+    else if (character === ";" && depth <= 0)
+      return index + 1;
+    if (CLOSES.has(character) && depth <= 0 && bodied)
+      return index + 1;
+  }
+  return source.length;
+};
+var normalize = (declaration) => declaration.replace(/\s+/gu, " ").trim();
+var reExported = (body) => body.split(",").map((part) => part.trim().replace(/^type\s+/u, "")).filter((clause) => clause !== "").map((clause) => [
+  clause.split(/\s+as\s+/u).at(LAST2)?.trim(),
+  clause
+]).filter((pair) => pair[0] !== undefined && IDENTIFIER.test(pair[0]));
+var exportedDeclarations = (source) => {
+  const found = new Map;
+  const add = (name, declaration) => {
+    const existing = found.get(name);
+    found.set(name, existing === undefined ? declaration : `${existing}
+${declaration}`);
+  };
+  for (const match of source.matchAll(DECLARATION)) {
+    const [, keyword, name] = match;
+    if (name === undefined || match.index === undefined)
+      continue;
+    add(name, normalize(source.slice(match.index, declarationEnd(source, match.index + match[0].length, BODIED.has(keyword ?? "")))));
+  }
+  for (const match of source.matchAll(NAMED_EXPORT))
+    for (const [exported, clause] of reExported(match[1] ?? ""))
+      add(exported, `export { ${clause} }`);
+  return found;
+};
+var surfaceOfArchive = (archive) => surfaceOfFiles([...readTar(archive, (path) => path.endsWith(".d.ts")).values()].map(asText));
+var surfaceOfFiles = (files) => {
+  const surface = new Map;
+  for (const source of files)
+    for (const [name, declaration] of exportedDeclarations(source)) {
+      const known = surface.get(name);
+      if (known === undefined || isStub(known) && !isStub(declaration))
+        surface.set(name, declaration);
+    }
+  return surface;
+};
+var SHAPE = {
+  members: "members",
+  parameters: "parameters",
+  types: "types",
+  unknown: "unknown"
+};
+var parametersOf = (declaration) => {
+  let depth = 0;
+  let start = NOWHERE;
+  for (const [index, character] of [...declaration].entries()) {
+    if (character === "{" && depth === 0)
+      return "";
+    depth += character === "(" ? 1 : 0;
+    if (character === "(" && depth === 1)
+      start = index;
+    depth -= character === ")" ? 1 : 0;
+    if (character === ")" && depth === 0 && start > NOWHERE)
+      return declaration.slice(start, index + 1);
+  }
+  return "";
+};
+var membersOf = (declaration) => {
+  const opened = declaration.indexOf("{");
+  if (opened < 0)
+    return new Set;
+  const members = new Set;
+  let depth = 0;
+  let segment = "";
+  const take = () => {
+    const [, name] = MEMBER.exec(segment.trim()) ?? [];
+    if (name !== undefined)
+      members.add(name);
+    segment = "";
+  };
+  for (const character of declaration.slice(opened)) {
+    const opening = OPENS.has(character);
+    const closing = CLOSES.has(character);
+    depth += opening ? 1 : 0;
+    if (opening && depth === 1)
+      segment = "";
+    depth -= closing ? 1 : 0;
+    if (opening || closing || depth !== 1)
+      continue;
+    if (character === ";" || character === ",")
+      take();
+    else
+      segment += character;
+  }
+  take();
+  return members;
+};
+var sameNames = (left, right) => left.size === right.size && [...left].every((name) => right.has(name));
+var changeShape = (change) => {
+  if (isStub(change.before) !== isStub(change.after))
+    return SHAPE.unknown;
+  if (parametersOf(change.before) !== parametersOf(change.after))
+    return SHAPE.parameters;
+  if (!sameNames(membersOf(change.before), membersOf(change.after)))
+    return SHAPE.members;
+  return SHAPE.types;
+};
+var diffSurface = (before, after) => {
+  const removed = [];
+  const changed = [];
+  for (const [name, declaration] of before) {
+    const now = after.get(name);
+    if (now === undefined)
+      removed.push(name);
+    else if (now !== declaration)
+      changed.push({
+        after: now,
+        before: declaration,
+        name,
+        shape: changeShape({ after: now, before: declaration })
+      });
+  }
+  return {
+    added: [...after.keys()].filter((name) => !before.has(name)),
+    changed,
+    removed
+  };
+};
+var notable = (diff) => diff.changed.filter((change) => change.shape === "parameters" || change.shape === "members");
+
+// src/entries.ts
+var loadEntry = async (path) => {
+  try {
+    const module = await import(pathToFileURL(path).href);
+    const exported = typeof module === "object" && module !== null && "default" in module ? module.default : undefined;
+    const read = { exported };
+    return read;
+  } catch (error) {
+    const failed = {
+      failure: error instanceof Error ? error.message : String(error)
+    };
+    return failed;
+  }
+};
+var ENTRY = /\.[cm]?ts$/u;
+var builtSurface = async (packageRoot, out = "dist") => {
+  const root = join(packageRoot, out);
+  const sources = [];
+  const walk = async (directory) => {
+    const found = await readdir(directory, { withFileTypes: true }).catch(() => []);
+    await Promise.all(found.map(async (entry) => {
+      const path = join(directory, entry.name);
+      if (entry.isDirectory())
+        return walk(path);
+      if (!entry.name.endsWith(".d.ts"))
+        return;
+      sources.push(await readFile(path, "utf8").catch(() => ""));
+      return;
+    }));
+  };
+  await walk(root);
+  return sources.length === 0 ? undefined : surfaceOfFiles(sources);
+};
+var changelogPaths = (packageRoot) => ({
+  history: join(packageRoot, "changelog", "history.md"),
+  json: join(packageRoot, CHANGELOG_FILE),
+  markdown: join(packageRoot, CHANGELOG_MARKDOWN),
+  unreleased: join(packageRoot, UNRELEASED_DIRECTORY)
+});
+var loadUnreleased = async (packageRoot) => {
+  const directory = join(packageRoot, UNRELEASED_DIRECTORY);
+  const names = await readdir(directory).catch(() => []);
+  const entries = [];
+  const problems = [];
+  for (const name of names.filter((file) => ENTRY.test(file)).sort()) {
+    const file = join(UNRELEASED_DIRECTORY, name);
+    const loaded = await loadEntry(join(directory, name));
+    if (loaded.failure !== undefined)
+      problems.push(`${file}: ${loaded.failure}`);
+    const checked = loaded.failure === undefined ? validateChange(loaded.exported, file) : undefined;
+    if (checked?.problems)
+      problems.push(...checked.problems);
+    if (checked?.change !== undefined)
+      entries.push({ change: checked.change, file });
+  }
+  return { entries, problems };
+};
+var readJsonFile = async (path) => {
+  const source = await readFile(path, "utf8").catch(() => {
+    return;
+  });
+  if (source === undefined)
+    return;
+  try {
+    const document = JSON.parse(source);
+    return document;
+  } catch {
+    return;
+  }
+};
+
+// src/reconcile.ts
+var describeReconciliation = (found) => {
+  const lines = [];
+  for (const entry of found.unannounced)
+    lines.push(entry.kind === "removed" ? `\`${entry.name}\` is no longer exported and no entry says so` : `\`${entry.name}\` changed its ${entry.kind} and no entry says so`);
+  for (const name of found.unknownSymbols)
+    lines.push(`an entry names \`${name}\`, which this package does not export`);
+  return lines;
+};
+var reconcile = (input) => {
+  const announced = new Set(input.changes.filter(isDisruptive).flatMap((change) => [...change.symbols]));
+  const unannounced = [
+    ...input.diff.removed.map((name) => ({ kind: "removed", name })),
+    ...notable(input.diff).map((change) => ({
+      kind: change.shape === "parameters" ? "parameters" : "members",
+      name: change.name
+    }))
+  ].filter((entry) => !announced.has(entry.name));
+  const unknownSymbols = [
+    ...new Set(input.changes.flatMap((change) => [...change.symbols ?? []]).filter((name) => !input.known.has(name)))
+  ];
+  return { unannounced, unknownSymbols };
+};
+
+// src/registry.ts
+import { gunzipSync } from "zlib";
+var ABBREVIATED = "application/vnd.npm.install-v1+json";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var readPackument = (body) => {
+  if (!isRecord2(body) || !isRecord2(body.versions))
+    return;
+  const tarballs = {};
+  for (const [version, entry] of Object.entries(body.versions)) {
+    if (!isRecord2(entry) || !isRecord2(entry.dist))
+      continue;
+    const { tarball } = entry.dist;
+    if (typeof tarball === "string")
+      tarballs[version] = tarball;
+  }
+  const tags = body["dist-tags"];
+  const latest = isRecord2(tags) ? tags.latest : undefined;
+  return {
+    ...typeof latest === "string" ? { latest } : {},
+    published: Object.keys(body.versions),
+    tarballs
+  };
+};
+var packageArchive = async (name, version, options = {}) => {
+  const call = options.fetch ?? fetch;
+  const versions = await packageVersions(name, options);
+  const url = versions?.tarballs[version];
+  if (url === undefined)
+    return;
+  try {
+    const response = await call(url);
+    if (!response.ok)
+      return;
+    return new Uint8Array(gunzipSync(new Uint8Array(await response.arrayBuffer())));
+  } catch {
+    return;
+  }
+};
+var packageVersions = async (name, options = {}) => {
+  const call = options.fetch ?? fetch;
+  try {
+    const response = await call(`${options.registry ?? DEFAULT_REGISTRY}/${name.replace("/", "%2f")}`, { headers: { accept: ABBREVIATED } });
+    if (!response.ok)
+      return;
+    return readPackument(await response.json());
+  } catch {
+    return;
+  }
+};
+var publishedChangelog = async (name, version, options = {}) => {
+  const archive = await packageArchive(name, version, options);
+  if (!archive)
+    return;
+  const file = readTar(archive, (path) => path === CHANGELOG_FILE).get(CHANGELOG_FILE);
+  if (!file)
+    return;
+  try {
+    return parseChangelog(JSON.parse(asText(file))).changelog;
+  } catch {
+    return;
+  }
+};
+var publishedSurface = async (name, version, options = {}) => {
+  const archive = await packageArchive(name, version, options);
+  return archive === undefined ? undefined : surfaceOfArchive(archive);
+};
+
+// src/write.ts
+var HEADING = {
+  added: "Added",
+  breaking: "Breaking",
+  changed: "Changed",
+  deprecated: "Deprecated",
+  fixed: "Fixed",
+  internal: "Internal",
+  removed: "Removed",
+  security: "Security"
+};
+var ORDER = [
+  "breaking",
+  "removed",
+  "deprecated",
+  "security",
+  "added",
+  "changed",
+  "fixed",
+  "internal"
+];
+var migrationLine = (migration) => {
+  if ("rename" in migration)
+    return `Rename \`${migration.rename.from}\` to \`${migration.rename.to}\`.`;
+  if ("moved" in migration)
+    return `Import \`${migration.moved.symbol}\` from \`${migration.moved.to}\` instead of \`${migration.moved.from}\`.`;
+  if ("resubpath" in migration)
+    return `Import from \`${migration.resubpath.to}\` instead of \`${migration.resubpath.from}\`.`;
+  return migration.instruction;
+};
+var renderChange = (change) => {
+  const symbols = change.symbols && change.symbols.length > 0 ? ` (${change.symbols.map((name) => `\`${name}\``).join(", ")})` : "";
+  const lines = [`- **${change.summary}**${symbols}`];
+  if (change.detail !== undefined)
+    lines.push(`  ${change.detail}`);
+  if (isDisruptive(change)) {
+    lines.push(`  _Migration:_ ${change.migration.instruction}`);
+    const mechanical = migrationLine(change.migration);
+    if (mechanical !== change.migration.instruction)
+      lines.push(`  _Applied automatically:_ ${mechanical}`);
+  }
+  if (change.reference !== undefined)
+    lines.push(`  See ${change.reference}.`);
+  return lines.join(`
+`);
+};
+var renderRelease = (release) => {
+  const sections = ORDER.map((kind) => {
+    const changes = release.changes.filter((entry) => entry.kind === kind);
+    if (changes.length === 0)
+      return null;
+    return [`### ${HEADING[kind]}`, "", ...changes.map(renderChange)].join(`
+`);
+  }).filter((section) => section !== null);
+  return [
+    `## ${release.version} \u2014 ${release.date}`,
+    ...release.note === undefined ? [] : ["", release.note],
+    "",
+    sections.join(`
+
+`)
+  ].join(`
+`);
+};
+var renderChangelogJson = (changelog) => `${JSON.stringify({
+  contract: CHANGELOG_CONTRACT,
+  name: changelog.name,
+  releases: [...changelog.releases].sort((left, right) => compareVersions(right.version, left.version)).map((release) => ({
+    changes: release.changes.map((change) => ({
+      ...change.detail === undefined ? {} : { detail: change.detail },
+      kind: change.kind,
+      ...isDisruptive(change) ? { migration: change.migration } : {},
+      ...change.reference === undefined ? {} : { reference: change.reference },
+      summary: change.summary,
+      ...change.symbols && change.symbols.length > 0 ? { symbols: change.symbols } : {}
+    })),
+    date: release.date,
+    ...release.note === undefined ? {} : { note: release.note },
+    version: release.version
+  }))
+}, null, "\t")}
+`;
+var renderMarkdown = (changelog, options = {}) => {
+  const releases = [...changelog.releases].sort((left, right) => compareVersions(right.version, left.version));
+  const head = [
+    "# Changelog",
+    "",
+    `All notable changes to \`${changelog.name}\`.`,
+    "",
+    "This file is generated by `absolute-changelog` from the entries in",
+    "`changelog/`. Edit an entry, not this file \u2014 and add new ones under",
+    "`changelog/unreleased/`."
+  ].join(`
+`);
+  const body = releases.map(renderRelease).join(`
+
+`);
+  const tail = options.history === undefined || options.history.trim() === "" ? "" : ["---", "", "## Earlier releases", "", options.history.trim()].join(`
+`);
+  return `${[head, body, tail].filter((part) => part !== "").join(`
+
+`)}
+`;
+};
+
+// src/cli.ts
+class CliError extends Error {
+}
+var isChangeKind = (value) => CHANGE_KINDS.some((kind) => kind === value);
+var isReleaseKind = (value) => RELEASE_KINDS.some((kind) => kind === value);
+var RELEASE_KINDS = ["major", "minor", "patch", "prerelease"];
+var SLUG_MAX_LENGTH = 48;
+var ISO_DATE_LENGTH = 10;
+var PREVIEW_LINES = 40;
+var readFlags = (argv) => {
+  const flags = {};
+  let skip = false;
+  for (const [index, argument] of argv.entries()) {
+    const consumed = skip;
+    skip = false;
+    if (consumed || !argument.startsWith("--"))
+      continue;
+    const [name, inline] = argument.slice(2).split("=");
+    if (name === undefined || name === "")
+      continue;
+    const next = argv[index + 1];
+    const takesNext = inline === undefined && next !== undefined && !next.startsWith("--");
+    skip = takesNext;
+    flags[name] = inline ?? (takesNext && next !== undefined ? next : true);
+  }
+  return flags;
+};
+var text = (flags, name) => {
+  const value = flags[name];
+  return typeof value === "string" ? value : undefined;
+};
+var list = (flags, name) => {
+  const value = text(flags, name);
+  return value === undefined ? [] : value.split(",").map((part) => part.trim()).filter((part) => part !== "");
+};
+var isPackage = (value) => typeof value === "object" && value !== null;
+var readPackage = async (root) => {
+  const document = await readJsonFile(join2(root, "package.json"));
+  if (!isPackage(document) || typeof document.name !== "string" || typeof document.version !== "string")
+    throw new CliError("No package.json with a name and a version here. Run this from a package root.");
+  const manifest = {
+    ...document,
+    name: document.name,
+    version: document.version
+  };
+  return manifest;
+};
+var readChangelog = async (root, name) => {
+  const document = await readJsonFile(changelogPaths(root).json);
+  if (document === undefined) {
+    const empty = {
+      contract: CHANGELOG_CONTRACT,
+      name,
+      releases: []
+    };
+    return empty;
+  }
+  const read = parseChangelog(document);
+  if (read.problems)
+    throw new CliError([`${CHANGELOG_FILE} is not a changelog:`, ...read.problems].join(`
+  `));
+  return read.changelog;
+};
+var historyOf = async (root) => readFile2(changelogPaths(root).history, "utf8").catch(() => {
+  return;
+});
+var writeBoth = async (root, changelog) => {
+  const paths = changelogPaths(root);
+  const history = await historyOf(root);
+  await writeFile(paths.json, renderChangelogJson(changelog));
+  await writeFile(paths.markdown, renderMarkdown(changelog, history === undefined ? {} : { history }));
+};
+var slug = (summary) => summary.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-|-$/gu, "").slice(0, SLUG_MAX_LENGTH) || "change";
+var add = async (root, flags) => {
+  const kind = text(flags, "kind");
+  const summary = text(flags, "summary");
+  if (!isChangeKind(kind))
+    throw new CliError(`--kind must be one of: ${CHANGE_KINDS.join(", ")}`);
+  if (summary === undefined)
+    throw new CliError("--summary is what the change is, in one line");
+  const symbols = list(flags, "symbol");
+  const disruptive = kind === "breaking" || kind === "removed";
+  if (disruptive && symbols.length === 0)
+    throw new CliError(`a ${kind} change must name the exports it affects: --symbol serve,createServer`);
+  const instruction = text(flags, "instruction");
+  if (disruptive && instruction === undefined)
+    throw new CliError(`a ${kind} change must say how to migrate: --instruction "\u2026"`);
+  const renameTo = text(flags, "rename-to");
+  const migration = renameTo !== undefined && symbols[0] !== undefined ? [
+    "\tmigration: {",
+    `		instruction: ${JSON.stringify(instruction)},`,
+    `		rename: { from: ${JSON.stringify(symbols[0])}, to: ${JSON.stringify(renameTo)} }`,
+    "\t},"
+  ] : [
+    `	migration: { instruction: ${JSON.stringify(instruction)}, manual: true },`
+  ];
+  const body = [
+    "import type { Change } from '@absolutejs/changelog';",
+    "",
+    "const entry: Change = {",
+    `	kind: ${JSON.stringify(kind)},`,
+    ...disruptive ? migration : [],
+    `	summary: ${JSON.stringify(summary)}${symbols.length > 0 ? "," : ""}`,
+    ...symbols.length > 0 ? [`	symbols: ${JSON.stringify(symbols)}`] : [],
+    "};",
+    "",
+    "export default entry;",
+    ""
+  ].join(`
+`);
+  const directory = join2(root, UNRELEASED_DIRECTORY);
+  await mkdir(directory, { recursive: true });
+  const file = join2(directory, `${slug(summary)}.ts`);
+  await writeFile(file, body);
+  console.log(`wrote ${file}`);
+};
+var release = async (root, flags) => {
+  const manifest = await readPackage(root);
+  const { entries, problems } = await loadUnreleased(root);
+  if (problems.length > 0)
+    throw new CliError(["These entries are not usable:", ...problems].join(`
+  `));
+  if (entries.length === 0)
+    throw new CliError(`Nothing to release: ${UNRELEASED_DIRECTORY} is empty. Add a change first.`);
+  const asked = text(flags, "as");
+  if (asked !== undefined && !isReleaseKind(asked))
+    throw new CliError(`--as must be one of: ${RELEASE_KINDS.join(", ")}`);
+  const changes = entries.map((entry) => entry.change);
+  const version = text(flags, "version") ?? nextVersion({
+    ...isReleaseKind(asked) ? { asked } : {},
+    changes,
+    current: manifest.version ?? "0.0.0"
+  });
+  if (version === undefined)
+    throw new CliError(`Could not work out the next version from ${manifest.version}.`);
+  const changelog = await readChangelog(root, manifest.name ?? "");
+  if (changelog.releases.some((entry) => entry.version === version))
+    throw new CliError(`${version} is already in the changelog.`);
+  const [first, ...rest] = changes;
+  if (first === undefined)
+    throw new CliError(`Nothing to release: ${UNRELEASED_DIRECTORY} is empty.`);
+  const next = {
+    changes: [first, ...rest],
+    date: text(flags, "date") ?? new Date().toISOString().slice(0, ISO_DATE_LENGTH),
+    version
+  };
+  const written = {
+    ...changelog,
+    releases: [next, ...changelog.releases]
+  };
+  if (flags.dry === true) {
+    console.log(renderMarkdown(written).split(`
+`).slice(0, PREVIEW_LINES).join(`
+`));
+    console.log(`
+(dry run: ${manifest.version} \u2192 ${version})`);
+    return;
+  }
+  await writeBoth(root, written);
+  await writeFile(join2(root, "package.json"), `${JSON.stringify({ ...manifest, version }, null, "\t")}
+`);
+  await Promise.all(entries.map((entry) => rm(join2(root, entry.file), { force: true })));
+  console.log(`${manifest.name} ${manifest.version} \u2192 ${version} (${entries.length} change${entries.length === 1 ? "" : "s"})`);
+};
+var check = async (root, flags) => {
+  const manifest = await readPackage(root);
+  const failures = [];
+  const { entries, problems } = await loadUnreleased(root);
+  failures.push(...problems);
+  const document = await readJsonFile(changelogPaths(root).json);
+  const read = document === undefined ? undefined : parseChangelog(document);
+  if (read?.problems)
+    throw new CliError([`${CHANGELOG_FILE} is not a changelog:`, ...read.problems].join(`
+  `));
+  const current = read?.changelog ?? {
+    contract: CHANGELOG_CONTRACT,
+    name: manifest.name ?? "",
+    releases: []
+  };
+  const [newest] = current.releases;
+  if (newest !== undefined && newest.version !== manifest.version)
+    failures.push(`package.json is ${manifest.version} and the newest release in ${CHANGELOG_FILE} is ${newest.version}`);
+  if (newest !== undefined && current.name !== manifest.name)
+    failures.push(`${CHANGELOG_FILE} is for ${current.name}, not ${manifest.name}`);
+  const history = await historyOf(root);
+  const expected = renderMarkdown(current, history === undefined ? {} : { history });
+  const actual = await readFile2(changelogPaths(root).markdown, "utf8").catch(() => {
+    return;
+  });
+  if (newest !== undefined && actual !== expected)
+    failures.push(`${CHANGELOG_MARKDOWN} is not what the entries say it should be \u2014 it is generated; run \`absolute-changelog release\` or restore it`);
+  const tsconfig = await readJsonFile(join2(root, "tsconfig.json"));
+  const include = isPackage(tsconfig) ? tsconfig.include : undefined;
+  if (Array.isArray(include) && !coversEntries(include))
+    failures.push('tsconfig.json does not compile changelog/, so nothing is checking the entries \u2014 add "changelog/**/*" to its include list');
+  const offline = flags.offline === true;
+  const built = await builtSurface(root);
+  if (!offline && built !== undefined && newest !== undefined) {
+    const published = await publishedSurface(manifest.name ?? "", newest.version);
+    if (published === undefined)
+      console.warn(`  (could not read ${manifest.name}@${newest.version} from the registry; the types were not checked)`);
+    failures.push(...published === undefined ? [] : describeReconciliation(reconcile({
+      changes: entries.map((entry) => entry.change),
+      diff: diffSurface(published, built),
+      known: new Set([...published.keys(), ...built.keys()])
+    })));
+  }
+  if (failures.length > 0)
+    throw new CliError(["This package\u2019s changelog does not hold:", ...failures].join(`
+  `));
+  console.log(`${manifest.name}@${manifest.version}: changelog holds (${entries.length} pending, ${current.releases.length} released)`);
+};
+var CHECKING_CONFIGS = ["tsconfig.json", "tsconfig.eslint.json"];
+var coversEntries = (include) => Array.isArray(include) && include.some((entry) => typeof entry === "string" && entry.startsWith("changelog"));
+var includeEntriesIn = async (root, file) => {
+  const path = join2(root, file);
+  const document = await readJsonFile(path);
+  if (!isPackage(document) || !Array.isArray(document.include))
+    return false;
+  if (coversEntries(document.include))
+    return false;
+  await writeFile(path, `${JSON.stringify({ ...document, include: [...document.include, "changelog/**/*"] }, null, "\t")}
+`);
+  return true;
+};
+var includeEntries = async (root) => {
+  const wired = await Promise.all(CHECKING_CONFIGS.map((file) => includeEntriesIn(root, file)));
+  return wired.some(Boolean) ? undefined : "no tsconfig include list to wire \u2014 make sure changelog/ is compiled by something";
+};
+var adopt = async (root) => {
+  const manifest = await readPackage(root);
+  const paths = changelogPaths(root);
+  await mkdir(paths.unreleased, { recursive: true });
+  await writeFile(join2(paths.unreleased, ".gitkeep"), "# Entries wait here. One file per change; `absolute-changelog release` consumes them.\n");
+  if (existsSync(paths.markdown) && !existsSync(paths.history)) {
+    const previous = await readFile2(paths.markdown, "utf8");
+    await mkdir(join2(root, "changelog"), { recursive: true });
+    await writeFile(paths.history, previous.replace(/^#\s+Changelog\s*/u, "").trimStart());
+    await rm(paths.markdown, { force: true });
+  }
+  const files = manifest.files ?? [];
+  const wanted = [CHANGELOG_FILE, CHANGELOG_MARKDOWN].filter((entry) => !files.includes(entry));
+  if (wanted.length > 0)
+    await writeFile(join2(root, "package.json"), `${JSON.stringify({ ...manifest, files: [...files, ...wanted].sort() }, null, "\t")}
+`);
+  const note = await includeEntries(root);
+  if (note !== undefined)
+    console.warn(`  (${note})`);
+  const changelog = await readChangelog(root, manifest.name ?? "");
+  await writeBoth(root, changelog);
+  console.log(`${manifest.name}: ready. Add changes with \`absolute-changelog add\`, release with \`absolute-changelog release\`.`);
+};
+var main = async () => {
+  const [command = "", ...argv] = process.argv.slice(2);
+  const flags = readFlags(argv);
+  const root = process.cwd();
+  if (command === "add")
+    return add(root, flags);
+  if (command === "release")
+    return release(root, flags);
+  if (command === "check")
+    return check(root, flags);
+  if (command === "adopt")
+    return adopt(root);
+  throw new CliError("Usage: absolute-changelog <add|release|check|adopt> [options]");
+};
+await main().catch((error) => {
+  console.error(error instanceof CliError ? error.message : `absolute-changelog failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});
+
+//# debugId=E1354AD9C119C96264756E2164756E21
+//# sourceMappingURL=cli.js.map