@releasekit/release 0.3.0 → 0.4.0

package/dist/chunk-YZHGXRG6.js

@@ -0,0 +1,651 @@
+// ../core/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+function readPackageVersion(importMetaUrl) {
+  try {
+    const dir = path.dirname(fileURLToPath(importMetaUrl));
+    const packageJsonPath = path.resolve(dir, "../package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var LOG_LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var PREFIXES = {
+  error: "[ERROR]",
+  warn: "[WARN]",
+  info: "[INFO]",
+  debug: "[DEBUG]",
+  trace: "[TRACE]"
+};
+var COLORS = {
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.blue,
+  debug: chalk.gray,
+  trace: chalk.dim
+};
+var currentLevel = "info";
+var quietMode = false;
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setQuietMode(quiet) {
+  quietMode = quiet;
+}
+function setJsonMode(_json) {
+}
+function shouldLog(level) {
+  if (quietMode && level !== "error") return false;
+  return LOG_LEVELS[level] <= LOG_LEVELS[currentLevel];
+}
+function log(message, level = "info") {
+  if (!shouldLog(level)) return;
+  const formatted = COLORS[level](`${PREFIXES[level]} ${message}`);
+  console.error(formatted);
+}
+function error(message) {
+  log(message, "error");
+}
+function warn(message) {
+  log(message, "warn");
+}
+function info(message) {
+  log(message, "info");
+}
+function success(message) {
+  if (!shouldLog("info")) return;
+  console.error(chalk.green(`[SUCCESS] ${message}`));
+}
+var ReleaseKitError = class _ReleaseKitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+  logError() {
+    log(this.message, "error");
+    if (this.suggestions.length > 0) {
+      log("\nSuggested solutions:", "info");
+      for (const [i, suggestion] of this.suggestions.entries()) {
+        log(`${i + 1}. ${suggestion}`, "info");
+      }
+    }
+  }
+  static isReleaseKitError(error2) {
+    return error2 instanceof _ReleaseKitError;
+  }
+};
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  CONFIG_ERROR: 2,
+  INPUT_ERROR: 3,
+  TEMPLATE_ERROR: 4,
+  LLM_ERROR: 5,
+  GITHUB_ERROR: 6,
+  GIT_ERROR: 7,
+  VERSION_ERROR: 8,
+  PUBLISH_ERROR: 9
+};
+
+// src/release.ts
+import { execSync } from "child_process";
+
+// ../config/dist/index.js
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as TOML from "smol-toml";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { z as z2 } from "zod";
+import { z } from "zod";
+import * as fs22 from "fs";
+import * as os from "os";
+import * as path22 from "path";
+var ConfigError = class extends ReleaseKitError {
+  code = "CONFIG_ERROR";
+  suggestions;
+  constructor(message, suggestions) {
+    super(message);
+    this.suggestions = suggestions ?? [
+      "Check that releasekit.config.json exists and is valid JSON",
+      "Run with --verbose for more details"
+    ];
+  }
+};
+var MAX_JSONC_LENGTH = 1e5;
+function parseJsonc(content) {
+  if (content.length > MAX_JSONC_LENGTH) {
+    throw new Error(`JSONC content too long: ${content.length} characters (max ${MAX_JSONC_LENGTH})`);
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    const cleaned = content.replace(/\/\/[^\r\n]{0,10000}$/gm, "").replace(/\/\*[\s\S]{0,50000}?\*\//g, "").trim();
+    return JSON.parse(cleaned);
+  }
+}
+var GitConfigSchema = z.object({
+  remote: z.string().default("origin"),
+  branch: z.string().default("main"),
+  pushMethod: z.enum(["auto", "ssh", "https"]).default("auto"),
+  /**
+   * Optional env var name containing a GitHub token for HTTPS pushes.
+   * When set, publish steps can use this token without mutating git remotes.
+   */
+  httpsTokenEnv: z.string().optional(),
+  push: z.boolean().optional(),
+  skipHooks: z.boolean().optional()
+});
+var MonorepoConfigSchema = z.object({
+  mode: z.enum(["root", "packages", "both"]).optional(),
+  rootPath: z.string().optional(),
+  packagesPath: z.string().optional(),
+  mainPackage: z.string().optional()
+});
+var BranchPatternSchema = z.object({
+  pattern: z.string(),
+  releaseType: z.enum(["major", "minor", "patch", "prerelease"])
+});
+var VersionCargoConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  paths: z.array(z.string()).optional()
+});
+var VersionConfigSchema = z.object({
+  tagTemplate: z.string().default("v{version}"),
+  packageSpecificTags: z.boolean().default(false),
+  preset: z.string().default("conventional"),
+  sync: z.boolean().default(true),
+  packages: z.array(z.string()).default([]),
+  mainPackage: z.string().optional(),
+  updateInternalDependencies: z.enum(["major", "minor", "patch", "no-internal-update"]).default("minor"),
+  skip: z.array(z.string()).optional(),
+  commitMessage: z.string().optional(),
+  versionStrategy: z.enum(["branchPattern", "commitMessage"]).default("commitMessage"),
+  branchPatterns: z.array(BranchPatternSchema).optional(),
+  defaultReleaseType: z.enum(["major", "minor", "patch", "prerelease"]).optional(),
+  mismatchStrategy: z.enum(["error", "warn", "ignore", "prefer-package", "prefer-git"]).default("warn"),
+  versionPrefix: z.string().default(""),
+  prereleaseIdentifier: z.string().optional(),
+  strictReachable: z.boolean().default(false),
+  cargo: VersionCargoConfigSchema.optional()
+});
+var NpmConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  auth: z.enum(["auto", "oidc", "token"]).default("auto"),
+  provenance: z.boolean().default(true),
+  access: z.enum(["public", "restricted"]).default("public"),
+  registry: z.string().default("https://registry.npmjs.org"),
+  copyFiles: z.array(z.string()).default(["LICENSE"]),
+  tag: z.string().default("latest")
+});
+var CargoPublishConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  noVerify: z.boolean().default(false),
+  publishOrder: z.array(z.string()).default([]),
+  clean: z.boolean().default(false)
+});
+var PublishGitConfigSchema = z.object({
+  push: z.boolean().default(true),
+  pushMethod: z.enum(["auto", "ssh", "https"]).optional(),
+  remote: z.string().optional(),
+  branch: z.string().optional(),
+  httpsTokenEnv: z.string().optional(),
+  skipHooks: z.boolean().optional()
+});
+var GitHubReleaseConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  draft: z.boolean().default(true),
+  perPackage: z.boolean().default(true),
+  prerelease: z.union([z.literal("auto"), z.boolean()]).default("auto"),
+  /**
+   * Controls the source for the GitHub release body.
+   * - 'auto': Use release notes if enabled, else changelog, else GitHub auto-generated.
+   * - 'releaseNotes': Use LLM-generated release notes (requires notes.releaseNotes.enabled: true).
+   * - 'changelog': Use formatted changelog entries.
+   * - 'generated': Use GitHub's auto-generated notes.
+   * - 'none': No body.
+   */
+  body: z.enum(["auto", "releaseNotes", "changelog", "generated", "none"]).default("auto")
+});
+var VerifyRegistryConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  maxAttempts: z.number().int().positive().default(5),
+  initialDelay: z.number().int().positive().default(15e3),
+  backoffMultiplier: z.number().positive().default(2)
+});
+var VerifyConfigSchema = z.object({
+  npm: VerifyRegistryConfigSchema.default({
+    enabled: true,
+    maxAttempts: 5,
+    initialDelay: 15e3,
+    backoffMultiplier: 2
+  }),
+  cargo: VerifyRegistryConfigSchema.default({
+    enabled: true,
+    maxAttempts: 10,
+    initialDelay: 3e4,
+    backoffMultiplier: 2
+  })
+});
+var PublishConfigSchema = z.object({
+  git: PublishGitConfigSchema.optional(),
+  npm: NpmConfigSchema.default({
+    enabled: true,
+    auth: "auto",
+    provenance: true,
+    access: "public",
+    registry: "https://registry.npmjs.org",
+    copyFiles: ["LICENSE"],
+    tag: "latest"
+  }),
+  cargo: CargoPublishConfigSchema.default({
+    enabled: false,
+    noVerify: false,
+    publishOrder: [],
+    clean: false
+  }),
+  githubRelease: GitHubReleaseConfigSchema.default({
+    enabled: true,
+    draft: true,
+    perPackage: true,
+    prerelease: "auto",
+    body: "auto"
+  }),
+  verify: VerifyConfigSchema.default({
+    npm: {
+      enabled: true,
+      maxAttempts: 5,
+      initialDelay: 15e3,
+      backoffMultiplier: 2
+    },
+    cargo: {
+      enabled: true,
+      maxAttempts: 10,
+      initialDelay: 3e4,
+      backoffMultiplier: 2
+    }
+  })
+});
+var TemplateConfigSchema = z.object({
+  path: z.string().optional(),
+  engine: z.enum(["handlebars", "liquid", "ejs"]).optional()
+});
+var LocationModeSchema = z.enum(["root", "packages", "both"]);
+var ChangelogConfigSchema = z.object({
+  mode: LocationModeSchema.optional(),
+  file: z.string().optional(),
+  templates: TemplateConfigSchema.optional()
+});
+var LLMOptionsSchema = z.object({
+  timeout: z.number().optional(),
+  maxTokens: z.number().optional(),
+  temperature: z.number().optional()
+});
+var LLMRetryConfigSchema = z.object({
+  maxAttempts: z.number().int().positive().optional(),
+  initialDelay: z.number().nonnegative().optional(),
+  maxDelay: z.number().positive().optional(),
+  backoffFactor: z.number().positive().optional()
+});
+var LLMTasksConfigSchema = z.object({
+  summarize: z.boolean().optional(),
+  enhance: z.boolean().optional(),
+  categorize: z.boolean().optional(),
+  releaseNotes: z.boolean().optional()
+});
+var LLMCategorySchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  scopes: z.array(z.string()).optional()
+});
+var ScopeRulesSchema = z.object({
+  allowed: z.array(z.string()).optional(),
+  caseSensitive: z.boolean().default(false),
+  invalidScopeAction: z.enum(["remove", "keep", "fallback"]).default("remove"),
+  fallbackScope: z.string().optional()
+});
+var ScopeConfigSchema = z.object({
+  mode: z.enum(["restricted", "packages", "none", "unrestricted"]).default("unrestricted"),
+  rules: ScopeRulesSchema.optional()
+});
+var LLMPromptOverridesSchema = z.object({
+  enhance: z.string().optional(),
+  categorize: z.string().optional(),
+  enhanceAndCategorize: z.string().optional(),
+  summarize: z.string().optional(),
+  releaseNotes: z.string().optional()
+});
+var LLMPromptsConfigSchema = z.object({
+  instructions: LLMPromptOverridesSchema.optional(),
+  templates: LLMPromptOverridesSchema.optional()
+});
+var LLMConfigSchema = z.object({
+  provider: z.string(),
+  model: z.string(),
+  baseURL: z.string().optional(),
+  apiKey: z.string().optional(),
+  options: LLMOptionsSchema.optional(),
+  concurrency: z.number().int().positive().optional(),
+  retry: LLMRetryConfigSchema.optional(),
+  tasks: LLMTasksConfigSchema.optional(),
+  categories: z.array(LLMCategorySchema).optional(),
+  style: z.string().optional(),
+  scopes: ScopeConfigSchema.optional(),
+  prompts: LLMPromptsConfigSchema.optional()
+});
+var ReleaseNotesConfigSchema = z.object({
+  mode: LocationModeSchema.optional(),
+  file: z.string().optional(),
+  templates: TemplateConfigSchema.optional(),
+  llm: LLMConfigSchema.optional()
+});
+var NotesInputConfigSchema = z.object({
+  source: z.string().optional(),
+  file: z.string().optional()
+});
+var NotesConfigSchema = z.object({
+  changelog: z.union([z.literal(false), ChangelogConfigSchema]).optional(),
+  releaseNotes: z.union([z.literal(false), ReleaseNotesConfigSchema]).optional(),
+  updateStrategy: z.enum(["prepend", "regenerate"]).optional()
+});
+var CILabelsConfigSchema = z.object({
+  stable: z.string().default("release:stable"),
+  prerelease: z.string().default("release:prerelease"),
+  skip: z.string().default("release:skip"),
+  major: z.string().default("release:major"),
+  minor: z.string().default("release:minor"),
+  patch: z.string().default("release:patch")
+});
+var CIConfigSchema = z.object({
+  releaseStrategy: z.enum(["manual", "direct", "standing-pr", "scheduled"]).default("direct"),
+  releaseTrigger: z.enum(["commit", "label"]).default("label"),
+  prPreview: z.boolean().default(true),
+  autoRelease: z.boolean().default(false),
+  /**
+   * Commit message prefixes that should not trigger a release.
+   * Defaults to `['chore: release ']` to match the release commit template
+   * (`chore: release ${packageName} v${version}`) and provide a
+   * secondary loop-prevention guard alongside `[skip ci]`.
+   */
+  skipPatterns: z.array(z.string()).default(["chore: release "]),
+  minChanges: z.number().int().positive().default(1),
+  labels: CILabelsConfigSchema.default({
+    stable: "release:stable",
+    prerelease: "release:prerelease",
+    skip: "release:skip",
+    major: "release:major",
+    minor: "release:minor",
+    patch: "release:patch"
+  })
+});
+var ReleaseCIConfigSchema = z.object({
+  skipPatterns: z.array(z.string().min(1)).optional(),
+  minChanges: z.number().int().positive().optional(),
+  /** Set to `false` to disable GitHub release creation in CI. */
+  githubRelease: z.literal(false).optional(),
+  /** Set to `false` to disable changelog generation in CI. */
+  notes: z.literal(false).optional()
+});
+var ReleaseConfigSchema = z.object({
+  /**
+   * Optional steps to enable. The version step always runs; only 'notes' and
+   * 'publish' can be opted out. Omitting a step is equivalent to --skip-<step>.
+   */
+  steps: z.array(z.enum(["notes", "publish"])).min(1).optional(),
+  ci: ReleaseCIConfigSchema.optional()
+});
+var ReleaseKitConfigSchema = z.object({
+  git: GitConfigSchema.optional(),
+  monorepo: MonorepoConfigSchema.optional(),
+  version: VersionConfigSchema.optional(),
+  publish: PublishConfigSchema.optional(),
+  notes: NotesConfigSchema.optional(),
+  ci: CIConfigSchema.optional(),
+  release: ReleaseConfigSchema.optional()
+});
+var MAX_INPUT_LENGTH = 1e4;
+function substituteVariables(value) {
+  if (value.length > MAX_INPUT_LENGTH) {
+    throw new Error(`Input too long: ${value.length} characters (max ${MAX_INPUT_LENGTH})`);
+  }
+  const envPattern = /\{env:([^}]{1,1000})\}/g;
+  const filePattern = /\{file:([^}]{1,1000})\}/g;
+  let result = value;
+  result = result.replace(envPattern, (_, varName) => {
+    return process.env[varName] ?? "";
+  });
+  result = result.replace(filePattern, (_, filePath) => {
+    const expandedPath = filePath.startsWith("~") ? path22.join(os.homedir(), filePath.slice(1)) : filePath;
+    try {
+      return fs22.readFileSync(expandedPath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  });
+  return result;
+}
+var SOLE_REFERENCE_PATTERN = /^\{(?:env|file):[^}]+\}$/;
+function substituteInObject(obj) {
+  if (typeof obj === "string") {
+    const result = substituteVariables(obj);
+    if (result === "" && SOLE_REFERENCE_PATTERN.test(obj)) {
+      return void 0;
+    }
+    return result;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => substituteInObject(item));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = substituteInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var AUTH_DIR = path22.join(os.homedir(), ".config", "releasekit");
+var AUTH_FILE = path22.join(AUTH_DIR, "auth.json");
+var CONFIG_FILE = "releasekit.config.json";
+function loadConfigFile(configPath) {
+  if (!fs3.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    const parsed = parseJsonc(content);
+    const substituted = substituteInObject(parsed);
+    return ReleaseKitConfigSchema.parse(substituted);
+  } catch (error2) {
+    if (error2 instanceof z2.ZodError) {
+      const issues = error2.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new ConfigError(`Config validation errors:
+${issues}`);
+    }
+    if (error2 instanceof SyntaxError) {
+      throw new ConfigError(`Invalid JSON in config file: ${error2.message}`);
+    }
+    throw error2;
+  }
+}
+function loadConfig(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const configPath = options?.configPath ?? path3.join(cwd, CONFIG_FILE);
+  return loadConfigFile(configPath);
+}
+function loadCIConfig(options) {
+  const config = loadConfig(options);
+  return config.ci;
+}
+
+// src/release.ts
+function getHeadCommitMessage(cwd) {
+  try {
+    return execSync("git log -1 --pretty=%s", { encoding: "utf-8", cwd }).trim();
+  } catch {
+    return null;
+  }
+}
+async function runRelease(inputOptions) {
+  const options = { ...inputOptions };
+  if (options.verbose) setLogLevel("debug");
+  if (options.quiet) setQuietMode(true);
+  if (options.json) setJsonMode(true);
+  let releaseKitConfig;
+  try {
+    releaseKitConfig = loadConfig({ cwd: options.projectDir, configPath: options.config });
+  } catch (err) {
+    error(`Failed to load release config: ${err instanceof Error ? err.message : String(err)}`);
+    throw err;
+  }
+  const releaseConfig = releaseKitConfig.release;
+  if (releaseConfig?.ci?.skipPatterns?.length) {
+    const headCommit = getHeadCommitMessage(options.projectDir);
+    if (headCommit) {
+      const matchedPattern = releaseConfig.ci.skipPatterns.find((p) => headCommit.startsWith(p));
+      if (matchedPattern) {
+        info(`Skipping release: commit message matches skip pattern "${matchedPattern}"`);
+        return null;
+      }
+    }
+  }
+  if (releaseConfig?.steps) {
+    if (!releaseConfig.steps.includes("notes") && !options.skipNotes) {
+      options.skipNotes = true;
+    }
+    if (!releaseConfig.steps.includes("publish") && !options.skipPublish) {
+      options.skipPublish = true;
+    }
+  }
+  if (releaseConfig?.ci?.notes === false && !options.skipNotes) {
+    options.skipNotes = true;
+  }
+  if (releaseConfig?.ci?.githubRelease === false && !options.skipGithubRelease) {
+    options.skipGithubRelease = true;
+  }
+  info("Running version analysis...");
+  const versionOutput = await runVersionStep({ ...options, dryRun: true });
+  versionOutput.dryRun = options.dryRun ?? false;
+  if (versionOutput.updates.length === 0) {
+    info("No releasable changes found");
+    return null;
+  }
+  if (releaseConfig?.ci?.minChanges !== void 0 && versionOutput.updates.length < releaseConfig.ci.minChanges) {
+    info(
+      `Skipping release: ${versionOutput.updates.length} package(s) to update, minimum is ${releaseConfig.ci.minChanges}`
+    );
+    return null;
+  }
+  if (!options.dryRun) {
+    const { flushPendingWrites } = await import("@releasekit/version");
+    flushPendingWrites();
+  }
+  info(`Found ${versionOutput.updates.length} package update(s)`);
+  for (const update of versionOutput.updates) {
+    info(`  ${update.packageName} \u2192 ${update.newVersion}`);
+  }
+  let notesGenerated = false;
+  let packageNotes;
+  let releaseNotes;
+  let notesFiles = [];
+  if (!options.skipNotes) {
+    info("Generating release notes...");
+    const notesResult = await runNotesStep(versionOutput, options);
+    packageNotes = notesResult.packageNotes;
+    releaseNotes = notesResult.releaseNotes;
+    notesFiles = notesResult.files;
+    notesGenerated = true;
+    success("Release notes generated");
+  }
+  let publishOutput;
+  if (!options.skipPublish) {
+    info("Publishing...");
+    publishOutput = await runPublishStep(versionOutput, options, releaseNotes ?? packageNotes, notesFiles);
+    success("Publish complete");
+  }
+  return { versionOutput, notesGenerated, packageNotes, releaseNotes, publishOutput };
+}
+async function runVersionStep(options) {
+  const { loadConfig: loadConfig2, VersionEngine, enableJsonOutput, getJsonData } = await import("@releasekit/version");
+  enableJsonOutput(options.dryRun);
+  const config = loadConfig2({ cwd: options.projectDir, configPath: options.config });
+  if (options.dryRun) config.dryRun = true;
+  if (options.sync) config.sync = true;
+  if (options.bump) config.type = options.bump;
+  if (options.prerelease) {
+    config.prereleaseIdentifier = options.prerelease === true ? "next" : options.prerelease;
+    config.isPrerelease = true;
+  }
+  const cliTargets = options.target ? options.target.split(",").map((t) => t.trim()) : [];
+  if (cliTargets.length > 0) {
+    config.packages = cliTargets;
+  }
+  const engine = new VersionEngine(config);
+  const pkgsResult = await engine.getWorkspacePackages();
+  const resolvedCount = pkgsResult.packages.length;
+  if (resolvedCount === 0) {
+    throw new Error("No packages found in workspace");
+  }
+  if (config.sync) {
+    engine.setStrategy("sync");
+    await engine.run(pkgsResult);
+  } else if (resolvedCount === 1) {
+    engine.setStrategy("single");
+    await engine.run(pkgsResult);
+  } else {
+    engine.setStrategy("async");
+    await engine.run(pkgsResult, cliTargets);
+  }
+  return getJsonData();
+}
+async function runNotesStep(versionOutput, options) {
+  const { parseVersionOutput, runPipeline, loadConfig: loadConfig2 } = await import("@releasekit/notes");
+  const config = loadConfig2(options.projectDir, options.config);
+  const input = parseVersionOutput(JSON.stringify(versionOutput));
+  const result = await runPipeline(input, config, options.dryRun);
+  return { packageNotes: result.packageNotes, releaseNotes: result.releaseNotes, files: result.files };
+}
+async function runPublishStep(versionOutput, options, releaseNotes, additionalFiles) {
+  const { runPipeline, loadConfig: loadConfig2 } = await import("@releasekit/publish");
+  const config = loadConfig2({ configPath: options.config });
+  if (options.branch) {
+    config.git.branch = options.branch;
+  }
+  const publishOptions = {
+    dryRun: options.dryRun,
+    registry: "all",
+    npmAuth: options.npmAuth ?? "auto",
+    skipGit: options.skipGit,
+    skipPublish: false,
+    skipGithubRelease: options.skipGithubRelease,
+    skipVerification: options.skipVerification,
+    json: options.json,
+    verbose: options.verbose,
+    releaseNotes,
+    additionalFiles
+  };
+  return runPipeline(versionOutput, config, publishOptions);
+}
+
+export {
+  readPackageVersion,
+  error,
+  warn,
+  info,
+  success,
+  EXIT_CODES,
+  loadConfig,
+  loadCIConfig,
+  runRelease
+};

package/dist/cli.d.ts

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