@releasekit/release 0.3.0-next.4 → 0.3.1

package/dist/chunk-J5NT6OX2.js

@@ -0,0 +1,438 @@
+import {
+  info,
+  loadCIConfig,
+  loadConfig,
+  runRelease,
+  success,
+  warn
+} from "./chunk-I5ABZWVU.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 "> No releasable changes detected. Run the release workflow manually if a release is needed.";
+    case "direct":
+      return "> No releasable changes detected. Merging this PR will not trigger a release.";
+    case "standing-pr":
+      return "> No releasable changes detected. Merging this PR will not affect the release PR.";
+    case "scheduled":
+      return "> No releasable changes detected. These changes will not be included in the next scheduled release.";
+    default:
+      return "> No releasable changes detected.";
+  }
+}
+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 ["> [!NOTE]", `> No release label detected. Add ${labelExamples} to trigger a release.`, ""];
+    }
+    if (labelContext.bumpLabel) {
+      return ["> [!NOTE]", `> 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]", 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/cli.d.ts

@@ -1 +1,6 @@
 #!/usr/bin/env node
+import { Command } from 'commander';
+
+declare function createReleaseProgram(): Command;
+
+export { createReleaseProgram };

package/dist/cli.js

@@ -1,41 +1,59 @@
 #!/usr/bin/env node
 import {
-  runRelease
-} from "./chunk-ONEIHH2F.js";
+  createReleaseCommand
+} from "./chunk-EDF3BZFF.js";
+import {
+  runPreview
+} from "./chunk-J5NT6OX2.js";
+import {
+  EXIT_CODES,
+  readPackageVersion
+} from "./chunk-I5ABZWVU.js";
 
 // src/cli.ts
-import { EXIT_CODES } from "@releasekit/core";
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { Command as Command2 } from "commander";
+
+// src/preview-command.ts
 import { Command } from "commander";
-var program = new Command();
-program.name("releasekit").description("Unified release pipeline: version, changelog, and publish").version("0.1.0").command("release", { isDefault: true }).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("--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,
-    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));
+function createPreviewCommand() {
+  return new Command("preview").description("Post a release preview comment on the current pull request").option("-c, --config <path>", "Path to config file").option("--project-dir <path>", "Project directory", process.cwd()).option("--pr <number>", "PR number (auto-detected from GitHub Actions)").option("--repo <owner/repo>", "Repository (auto-detected from GITHUB_REPOSITORY)").option("-p, --prerelease [identifier]", "Force prerelease preview (auto-detected by default)").option("--stable", "Force stable release preview (graduation from prerelease)", false).option(
+    "-d, --dry-run",
+    "Print the comment to stdout without posting (GitHub context not available in dry-run mode)",
+    false
+  ).action(async (opts) => {
+    try {
+      await runPreview({
+        config: opts.config,
+        projectDir: opts.projectDir,
+        pr: opts.pr,
+        repo: opts.repo,
+        prerelease: opts.prerelease,
+        stable: opts.stable,
+        dryRun: opts.dryRun
+      });
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(EXIT_CODES.GENERAL_ERROR);
     }
-    if (!result) {
-      process.exit(0);
-    }
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(EXIT_CODES.GENERAL_ERROR);
+  });
+}
+
+// src/cli.ts
+function createReleaseProgram() {
+  return new Command2().name("releasekit-release").description("Unified release pipeline: version, changelog, and publish").version(readPackageVersion(import.meta.url)).addCommand(createReleaseCommand(), { isDefault: true }).addCommand(createPreviewCommand());
+}
+var isMain = (() => {
+  try {
+    return process.argv[1] ? realpathSync(process.argv[1]) === fileURLToPath(import.meta.url) : false;
+  } catch {
+    return false;
   }
-});
-program.parse();
+})();
+if (isMain) {
+  createReleaseProgram().parse();
+}
+export {
+  createReleaseProgram
+};

package/dist/dispatcher.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+
+declare function createDispatcherProgram(): Command;
+
+export { createDispatcherProgram };

package/dist/dispatcher.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  createReleaseCommand
+} from "./chunk-EDF3BZFF.js";
+import {
+  readPackageVersion
+} from "./chunk-I5ABZWVU.js";
+
+// src/dispatcher.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { createNotesCommand } from "@releasekit/notes/cli";
+import { createPublishCommand } from "@releasekit/publish/cli";
+import { createVersionCommand } from "@releasekit/version/cli";
+import { Command } from "commander";
+function createDispatcherProgram() {
+  const program = new Command().name("releasekit").description("Unified release pipeline: version, changelog, and publish").version(readPackageVersion(import.meta.url));
+  program.addCommand(createReleaseCommand(), { isDefault: true });
+  program.addCommand(createVersionCommand());
+  program.addCommand(createNotesCommand());
+  program.addCommand(createPublishCommand());
+  return program;
+}
+var isMain = (() => {
+  try {
+    return process.argv[1] ? realpathSync(process.argv[1]) === fileURLToPath(import.meta.url) : false;
+  } catch {
+    return false;
+  }
+})();
+if (isMain) {
+  createDispatcherProgram().parse();
+}
+export {
+  createDispatcherProgram
+};

package/dist/index.d.ts

@@ -1,29 +1,3 @@
-import { VersionOutput } from '@releasekit/core';
-import { PublishOutput } from '@releasekit/publish';
-
-interface ReleaseOptions {
-    config?: string;
-    dryRun: boolean;
-    bump?: string;
-    prerelease?: string | boolean;
-    sync: boolean;
-    target?: string;
-    skipNotes: boolean;
-    skipPublish: boolean;
-    skipGit: boolean;
-    skipGithubRelease: boolean;
-    skipVerification: boolean;
-    json: boolean;
-    verbose: boolean;
-    quiet: boolean;
-    projectDir: string;
-}
-interface ReleaseOutput {
-    versionOutput: VersionOutput;
-    notesGenerated: boolean;
-    publishOutput?: PublishOutput;
-}
-
-declare function runRelease(options: ReleaseOptions): Promise<ReleaseOutput | null>;
-
-export { type ReleaseOptions, type ReleaseOutput, runRelease };
+export { PreviewOptions, runPreview } from './preview.ts';
+export { runRelease } from './release.ts';
+export { ReleaseOptions, ReleaseOutput } from './types.ts';

package/dist/index.js

@@ -1,6 +1,10 @@
+import {
+  runPreview
+} from "./chunk-J5NT6OX2.js";
 import {
   runRelease
-} from "./chunk-ONEIHH2F.js";
+} from "./chunk-I5ABZWVU.js";
 export {
+  runPreview,
   runRelease
 };