@releasekit/release 0.3.0 → 0.4.0

package/README.md

@@ -1,6 +1,10 @@
 # @releasekit/release
 
-Unified release pipeline: version, changelog, and publish in a single command.
+[![@releasekit/release](https://img.shields.io/badge/@releasekit-release-9feaf9?labelColor=1a1a1a&style=plastic)](https://www.npmjs.com/package/@releasekit/release)
+[![Version](https://img.shields.io/npm/v/@releasekit/release?color=28a745&labelColor=1a1a1a)](https://www.npmjs.com/package/@releasekit/release)
+[![Downloads](https://img.shields.io/npm/dw/@releasekit/release?color=6f42c1&labelColor=1a1a1a)](https://www.npmjs.com/package/@releasekit/release)
+
+**Unified release pipeline: version, changelog, and publish in a single command.**
 
 ## Features
 
@@ -71,6 +75,18 @@ If no releasable changes are found after step 1, the command exits with code 0 a
 | `-q, --quiet` | Suppress non-error output | `false` |
 | `--project-dir <path>` | Project directory | cwd |
 
+### `releasekit init`
+
+Create a default `releasekit.config.json` in the current directory.
+
+```bash
+releasekit init [--force]
+```
+
+Detects monorepo layout and sets `changelog.mode` accordingly. Adds `access: "public"` only for scoped packages (`@scope/name`), which npm defaults to restricted.
+
+Use `--force` to overwrite an existing config file.
+
 ### `releasekit preview`
 
 Posts a release preview comment on a pull request showing what would be released if merged.
@@ -275,6 +291,11 @@ jobs:
 
 A template is also available at [`templates/workflows/release-preview.yml`](../../templates/workflows/release-preview.yml).
 
+## Documentation
+
+**Getting Started**
+- [CI Setup](./docs/ci-setup.md) — GitHub Actions workflows (push, label, OIDC, PR preview, prerelease)
+
 ## License
 
 MIT

package/dist/chunk-I5CGC253.js

@@ -0,0 +1,438 @@
+import {
+  info,
+  loadCIConfig,
+  loadConfig,
+  runRelease,
+  success,
+  warn
+} from "./chunk-YZHGXRG6.js";
+
+// src/preview-context.ts
+import * as fs from "fs";
+function resolvePreviewContext(opts) {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error("GITHUB_TOKEN environment variable is required");
+  }
+  const prNumber = resolvePRNumber(opts.pr);
+  const { owner, repo } = resolveRepo(opts.repo);
+  return { prNumber, owner, repo, token };
+}
+function resolvePRNumber(cliValue) {
+  if (cliValue) {
+    const num = Number.parseInt(cliValue, 10);
+    if (Number.isNaN(num) || num <= 0) {
+      throw new Error(`Invalid PR number: ${cliValue}`);
+    }
+    return num;
+  }
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (eventPath && fs.existsSync(eventPath)) {
+    try {
+      const event = JSON.parse(fs.readFileSync(eventPath, "utf-8"));
+      if (event.pull_request?.number) {
+        return event.pull_request.number;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Could not determine PR number. Use --pr <number> or run in a GitHub Actions pull_request workflow.");
+}
+function resolveRepo(cliValue) {
+  const repoStr = cliValue ?? process.env.GITHUB_REPOSITORY;
+  if (!repoStr) {
+    throw new Error("Could not determine repository. Use --repo <owner/repo> or run in a GitHub Actions workflow.");
+  }
+  const parts = repoStr.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid repository format: ${repoStr}. Expected "owner/repo".`);
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+
+// src/preview-detect.ts
+import * as fs2 from "fs";
+import * as path from "path";
+function detectPrerelease(packagePaths, projectDir) {
+  const paths = packagePaths.length > 0 ? packagePaths.map((p) => path.join(projectDir, p, "package.json")) : [path.join(projectDir, "package.json")];
+  for (const pkgPath of paths) {
+    if (!fs2.existsSync(pkgPath)) continue;
+    try {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+      const result = parsePrerelease(pkg.version);
+      if (result.isPrerelease) return result;
+    } catch {
+    }
+  }
+  return { isPrerelease: false };
+}
+function parsePrerelease(version) {
+  if (!version) return { isPrerelease: false };
+  const match = version.match(/-([a-zA-Z0-9][a-zA-Z0-9-]*)(?:\.\d+)*(?:\+[^\s]+)?$/);
+  if (match) {
+    return { isPrerelease: true, identifier: match[1] };
+  }
+  return { isPrerelease: false };
+}
+
+// src/preview-format.ts
+var MARKER = "<!-- releasekit-preview -->";
+var FOOTER = "*Updated automatically by [ReleaseKit](https://github.com/goosewobbler/releasekit)*";
+var TYPE_LABELS = {
+  added: "Added",
+  changed: "Changed",
+  fixed: "Fixed",
+  security: "Security",
+  docs: "Documentation",
+  chore: "Chores",
+  test: "Tests",
+  feat: "Features",
+  fix: "Bug Fixes",
+  perf: "Performance",
+  refactor: "Refactoring",
+  style: "Styles",
+  build: "Build",
+  ci: "CI",
+  revert: "Reverts"
+};
+function getNoChangesMessage(strategy) {
+  switch (strategy) {
+    case "manual":
+      return "Run the release workflow manually if a release is needed.";
+    case "direct":
+      return "Merging this PR will not trigger a release.";
+    case "standing-pr":
+      return "Merging this PR will not affect the release PR.";
+    case "scheduled":
+      return "These changes will not be included in the next scheduled release.";
+    default:
+      return "";
+  }
+}
+function getIntroMessage(strategy, standingPrNumber) {
+  switch (strategy) {
+    case "direct":
+      return "This PR will trigger the following release when merged:";
+    case "standing-pr":
+      return standingPrNumber ? `These changes will be added to the release PR (#${standingPrNumber}) when merged:` : "Merging this PR will create a new release PR with the following changes:";
+    case "scheduled":
+      return "These changes will be included in the next scheduled release:";
+    default:
+      return "If released, this PR would include:";
+  }
+}
+function getLabelBanner(labelContext) {
+  if (!labelContext) return [];
+  if (labelContext.trigger === "commit") {
+    if (labelContext.skip) {
+      return ["> **Warning:** This PR is marked to skip release.", ""];
+    }
+    if (labelContext.bumpLabel === "major") {
+      return ["> **Important:** This PR is labeled for a **major** release.", ""];
+    }
+  }
+  if (labelContext.trigger === "label") {
+    if (labelContext.noBumpLabel) {
+      const labels = labelContext.labels;
+      const labelExamples = labels ? `\`${labels.patch}\`, \`${labels.minor}\`, or \`${labels.major}\`` : "a release label (e.g., `release:patch`, `release:minor`, `release:major`)";
+      return ["> No release label detected.", `> **Note:** Add ${labelExamples} to trigger a release.`, ""];
+    }
+    if (labelContext.bumpLabel) {
+      return [`> This PR is labeled for a **${labelContext.bumpLabel}** release.`, ""];
+    }
+  }
+  return [];
+}
+function formatPreviewComment(result, options) {
+  const strategy = options?.strategy ?? "direct";
+  const labelContext = options?.labelContext;
+  const lines = [MARKER, ""];
+  const banner = getLabelBanner(labelContext);
+  if (!result) {
+    lines.push("<details>", "<summary><b>Release Preview</b> \u2014 no release</summary>", "");
+    lines.push(...banner);
+    if (!labelContext?.noBumpLabel) {
+      lines.push(`> **Note:** No releasable changes detected. ${getNoChangesMessage(strategy)}`);
+    }
+    lines.push("", "---", FOOTER, "</details>");
+    return lines.join("\n");
+  }
+  const { versionOutput } = result;
+  const pkgCount = versionOutput.updates.length;
+  const pkgSummary = pkgCount === 1 ? `${versionOutput.updates[0]?.packageName} ${versionOutput.updates[0]?.newVersion}` : `${pkgCount} packages`;
+  lines.push("<details>", `<summary><b>Release Preview</b> \u2014 ${pkgSummary}</summary>`, "");
+  lines.push(...banner);
+  lines.push(getIntroMessage(strategy, options?.standingPrNumber), "");
+  lines.push("### Packages", "");
+  lines.push("| Package | Version |", "|---------|---------|");
+  for (const update of versionOutput.updates) {
+    lines.push(`| \`${update.packageName}\` | ${update.newVersion} |`);
+  }
+  lines.push("");
+  const sharedEntries = versionOutput.sharedEntries?.length ? versionOutput.sharedEntries : void 0;
+  const hasPackageChangelogs = versionOutput.changelogs.some((cl) => cl.entries.length > 0);
+  if (sharedEntries || hasPackageChangelogs) {
+    lines.push("### Changelog", "");
+    if (sharedEntries) {
+      lines.push("<details>", "<summary><b>Project-wide changes</b></summary>", "");
+      lines.push(...renderEntries(sharedEntries));
+      lines.push("</details>", "");
+    }
+    for (const changelog of versionOutput.changelogs) {
+      if (changelog.entries.length > 0) {
+        lines.push(...formatPackageChangelog(changelog));
+      }
+    }
+  }
+  if (versionOutput.tags.length > 0) {
+    lines.push("### Tags", "");
+    for (const tag of versionOutput.tags) {
+      lines.push(`- \`${tag}\``);
+    }
+    lines.push("");
+  }
+  lines.push("---", FOOTER, "</details>");
+  return lines.join("\n");
+}
+function renderEntries(entries) {
+  const lines = [];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!grouped.has(entry.type)) grouped.set(entry.type, []);
+    grouped.get(entry.type)?.push(entry);
+  }
+  const renderedTypes = /* @__PURE__ */ new Set();
+  for (const type of Object.keys(TYPE_LABELS)) {
+    const group = grouped.get(type);
+    if (group && group.length > 0) {
+      lines.push(...formatEntryGroup(type, group));
+      renderedTypes.add(type);
+    }
+  }
+  for (const [type, group] of grouped) {
+    if (!renderedTypes.has(type) && group.length > 0) {
+      lines.push(...formatEntryGroup(type, group));
+    }
+  }
+  return lines;
+}
+function formatPackageChangelog(changelog) {
+  const lines = [];
+  const prevVersion = changelog.previousVersion ?? "N/A";
+  const summary = `<b>${changelog.packageName}</b> ${prevVersion} \u2192 ${changelog.version}`;
+  lines.push("<details>", `<summary>${summary}</summary>`, "");
+  lines.push(...renderEntries(changelog.entries));
+  lines.push("</details>", "");
+  return lines;
+}
+function formatEntryGroup(type, entries) {
+  const label = TYPE_LABELS[type] ?? capitalize(type);
+  const lines = [`#### ${label}`, ""];
+  for (const entry of entries) {
+    let line = `- ${entry.description}`;
+    if (entry.scope) {
+      line += ` (\`${entry.scope}\`)`;
+    }
+    if (entry.issueIds && entry.issueIds.length > 0) {
+      line += ` ${entry.issueIds.join(", ")}`;
+    }
+    lines.push(line);
+  }
+  lines.push("");
+  return lines;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/preview-github.ts
+import { Octokit } from "@octokit/rest";
+function createOctokit(token) {
+  return new Octokit({ auth: token });
+}
+async function findPreviewComment(octokit, owner, repo, prNumber) {
+  const iterator = octokit.paginate.iterator(octokit.rest.issues.listComments, {
+    owner,
+    repo,
+    issue_number: prNumber,
+    per_page: 100
+  });
+  for await (const response of iterator) {
+    for (const comment of response.data) {
+      if (comment.body?.startsWith(MARKER)) {
+        return comment.id;
+      }
+    }
+  }
+  return null;
+}
+async function fetchPRLabels(octokit, owner, repo, prNumber) {
+  const { data } = await octokit.rest.issues.get({
+    owner,
+    repo,
+    issue_number: prNumber
+  });
+  return (data.labels ?? []).map((label) => typeof label === "string" ? label : label.name ?? "");
+}
+async function postOrUpdateComment(octokit, owner, repo, prNumber, body) {
+  const existingId = await findPreviewComment(octokit, owner, repo, prNumber);
+  if (existingId) {
+    await octokit.rest.issues.updateComment({
+      owner,
+      repo,
+      comment_id: existingId,
+      body
+    });
+  } else {
+    await octokit.rest.issues.createComment({
+      owner,
+      repo,
+      issue_number: prNumber,
+      body
+    });
+  }
+}
+
+// src/preview.ts
+var DEFAULT_LABELS = {
+  stable: "release:stable",
+  prerelease: "release:prerelease",
+  skip: "release:skip",
+  major: "release:major",
+  minor: "release:minor",
+  patch: "release:patch"
+};
+async function runPreview(options) {
+  const ciConfig = loadCIConfig({ cwd: options.projectDir, configPath: options.config });
+  if (ciConfig?.prPreview === false) {
+    info("PR preview is disabled in config (ci.prPreview: false)");
+    return;
+  }
+  let context;
+  let octokit;
+  if (!options.dryRun) {
+    try {
+      context = resolvePreviewContext({ pr: options.pr, repo: options.repo });
+      octokit = createOctokit(context.token);
+    } catch (error) {
+      warn(`Cannot post PR comment: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const { options: effectiveOptions, labelContext } = await applyLabelOverrides(options, ciConfig, context, octokit);
+  const strategy = ciConfig?.releaseStrategy ?? "direct";
+  let result = null;
+  if (!labelContext.noBumpLabel) {
+    const releaseConfig = loadConfig({ cwd: effectiveOptions.projectDir, configPath: effectiveOptions.config });
+    const prereleaseFlag = resolvePrerelease(
+      effectiveOptions,
+      releaseConfig.version?.packages ?? [],
+      effectiveOptions.projectDir
+    );
+    info("Analyzing release...");
+    result = await runRelease({
+      config: effectiveOptions.config,
+      dryRun: true,
+      sync: false,
+      bump: effectiveOptions.bump,
+      prerelease: prereleaseFlag,
+      skipNotes: true,
+      skipPublish: true,
+      skipGit: true,
+      skipGithubRelease: true,
+      skipVerification: true,
+      json: false,
+      verbose: false,
+      quiet: true,
+      projectDir: effectiveOptions.projectDir
+    });
+  } else {
+    info("No release label detected \u2014 skipping version analysis");
+  }
+  const commentBody = formatPreviewComment(result, { strategy, labelContext });
+  if (!context || !octokit) {
+    console.log(commentBody);
+    return;
+  }
+  info(`Posting preview comment on PR #${context.prNumber}...`);
+  await postOrUpdateComment(octokit, context.owner, context.repo, context.prNumber, commentBody);
+  success(`Preview comment posted on PR #${context.prNumber}`);
+}
+function resolvePrerelease(options, packagePaths, projectDir) {
+  if (options.stable) {
+    return void 0;
+  }
+  if (options.prerelease !== void 0) {
+    return options.prerelease;
+  }
+  const detected = detectPrerelease(packagePaths, projectDir);
+  if (detected.isPrerelease) {
+    info(`Detected prerelease version (identifier: ${detected.identifier})`);
+    return detected.identifier;
+  }
+  return void 0;
+}
+async function applyLabelOverrides(options, ciConfig, context, existingOctokit) {
+  const trigger = ciConfig?.releaseTrigger ?? "label";
+  const labels = ciConfig?.labels ?? DEFAULT_LABELS;
+  const defaultLabelContext = { trigger, skip: false, noBumpLabel: false };
+  if (!context) {
+    return {
+      options,
+      labelContext: { ...defaultLabelContext, noBumpLabel: trigger === "label" && !options.bump, labels }
+    };
+  }
+  let prLabels;
+  const octokitToUse = existingOctokit ?? createOctokit(context.token);
+  try {
+    prLabels = await fetchPRLabels(octokitToUse, context.owner, context.repo, context.prNumber);
+  } catch {
+    warn("Could not fetch PR labels \u2014 skipping label-driven overrides");
+    return {
+      options,
+      labelContext: { ...defaultLabelContext, noBumpLabel: trigger === "label", labels }
+    };
+  }
+  const result = { ...options };
+  const labelContext = { trigger, skip: false, noBumpLabel: false, labels };
+  if (trigger === "commit") {
+    if (prLabels.includes(labels.skip)) {
+      info(`PR label "${labels.skip}" detected \u2014 release will be skipped`);
+      labelContext.skip = true;
+    }
+    if (!labelContext.skip && prLabels.includes(labels.major)) {
+      info(`PR label "${labels.major}" detected \u2014 forcing major release`);
+      labelContext.bumpLabel = "major";
+      result.bump = "major";
+    }
+  } else {
+    if (prLabels.includes(labels.major)) {
+      info(`PR label "${labels.major}" detected \u2014 major release`);
+      labelContext.bumpLabel = "major";
+      result.bump = "major";
+    } else if (prLabels.includes(labels.minor)) {
+      info(`PR label "${labels.minor}" detected \u2014 minor release`);
+      labelContext.bumpLabel = "minor";
+      result.bump = "minor";
+    } else if (prLabels.includes(labels.patch)) {
+      info(`PR label "${labels.patch}" detected \u2014 patch release`);
+      labelContext.bumpLabel = "patch";
+      result.bump = "patch";
+    } else {
+      labelContext.noBumpLabel = true;
+    }
+  }
+  if (!options.stable && options.prerelease === void 0) {
+    if (prLabels.includes(labels.stable)) {
+      info(`PR label "${labels.stable}" detected \u2014 using stable release preview`);
+      result.stable = true;
+    } else if (prLabels.includes(labels.prerelease)) {
+      info(`PR label "${labels.prerelease}" detected \u2014 using prerelease preview`);
+      result.prerelease = true;
+    }
+  }
+  return { options: result, labelContext: { ...labelContext, labels } };
+}
+
+export {
+  runPreview
+};

package/dist/chunk-WNKYXS62.js

@@ -0,0 +1,46 @@
+import {
+  EXIT_CODES,
+  runRelease
+} from "./chunk-YZHGXRG6.js";
+
+// src/release-command.ts
+import { Command, Option } from "commander";
+function createReleaseCommand() {
+  return new Command("release").description("Run the full release pipeline").option("-c, --config <path>", "Path to config file").option("-d, --dry-run", "Preview all steps without side effects", false).option("-b, --bump <type>", "Force bump type (patch|minor|major)").option("-p, --prerelease [identifier]", "Create prerelease version").option("-s, --sync", "Use synchronized versioning across all packages", false).option("-t, --target <packages>", "Target specific packages (comma-separated)").option("--branch <name>", "Override the git branch used for push").addOption(new Option("--npm-auth <method>", "NPM auth method").choices(["auto", "oidc", "token"]).default("auto")).option("--skip-notes", "Skip changelog generation", false).option("--skip-publish", "Skip registry publishing and git operations", false).option("--skip-git", "Skip git commit/tag/push", false).option("--skip-github-release", "Skip GitHub release creation", false).option("--skip-verification", "Skip post-publish verification", false).option("-j, --json", "Output results as JSON", false).option("-v, --verbose", "Verbose logging", false).option("-q, --quiet", "Suppress non-error output", false).option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
+    const options = {
+      config: opts.config,
+      dryRun: opts.dryRun,
+      bump: opts.bump,
+      prerelease: opts.prerelease,
+      sync: opts.sync,
+      target: opts.target,
+      branch: opts.branch,
+      npmAuth: opts.npmAuth,
+      skipNotes: opts.skipNotes,
+      skipPublish: opts.skipPublish,
+      skipGit: opts.skipGit,
+      skipGithubRelease: opts.skipGithubRelease,
+      skipVerification: opts.skipVerification,
+      json: opts.json,
+      verbose: opts.verbose,
+      quiet: opts.quiet,
+      projectDir: opts.projectDir
+    };
+    try {
+      const result = await runRelease(options);
+      if (options.json && result) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      if (!result) {
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(EXIT_CODES.GENERAL_ERROR);
+    }
+  });
+}
+
+export {
+  createReleaseCommand
+};