gitverse-release 2.0.2 → 3.1.0

package/dist/cli.js

@@ -1,7 +1,1310 @@
 #!/usr/bin/env bun
-import {
-  release
-} from "./index.js";
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { resolve as resolve2 } from "node:path";
+
+// src/config.ts
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+var DEFAULT_CONFIG = {
+  changelog: {
+    showAuthor: true,
+    showHash: true,
+    types: {
+      build: "\uD83C\uDFD7️ Build System",
+      chore: "\uD83D\uDD27 Chores",
+      ci: "\uD83D\uDC77 CI/CD",
+      docs: "\uD83D\uDCDD Documentation",
+      feat: "✨ Features",
+      fix: "\uD83D\uDC1B Bug Fixes",
+      perf: "⚡ Performance",
+      refactor: "♻️ Refactoring",
+      revert: "⏪ Reverts",
+      style: "\uD83D\uDC84 Styling",
+      test: "✅ Tests"
+    }
+  },
+  git: {
+    commitChanges: true,
+    commitMessage: "chore(release): {{package}} v{{version}} [skip ci]",
+    push: true,
+    tagMessage: "Release {{package}} v{{version}}"
+  },
+  monorepo: {
+    enabled: false,
+    packages: []
+  },
+  versioning: {
+    allowPrerelease: false,
+    prereleasePrefix: "beta",
+    tagPrefix: "v"
+  }
+};
+async function loadConfig(configPath) {
+  const path = configPath || ".gitversereleaserc.json";
+  const fullPath = resolve(process.cwd(), path);
+  try {
+    const content = await readFile(fullPath, "utf-8");
+    const userConfig = JSON.parse(content);
+    return mergeConfig(DEFAULT_CONFIG, userConfig);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return DEFAULT_CONFIG;
+    }
+    throw new Error(`Failed to load config from ${fullPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function mergeConfig(defaults, user) {
+  return {
+    changelog: {
+      ...defaults.changelog,
+      ...user.changelog,
+      types: {
+        ...defaults.changelog.types,
+        ...user.changelog?.types
+      }
+    },
+    git: {
+      ...defaults.git,
+      ...user.git
+    },
+    monorepo: {
+      ...defaults.monorepo,
+      ...user.monorepo
+    },
+    versioning: {
+      ...defaults.versioning,
+      ...user.versioning
+    }
+  };
+}
+function validateConfig(config) {
+  if (config.monorepo.enabled && config.monorepo.packages.length === 0) {
+    throw new Error("Monorepo mode is enabled but no packages are configured");
+  }
+  for (const pkg of config.monorepo.packages) {
+    if (!(pkg.name && pkg.path && pkg.packageName && pkg.tagPrefix)) {
+      throw new Error(`Invalid package configuration for ${pkg.name || "unknown"}`);
+    }
+  }
+}
+
+// ../sdk/dist/api/organizations.js
+class j {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  async checkMembership(b, h) {
+    try {
+      return await this.client.get(`/orgs/${b}/members/${h}`), true;
+    } catch (d) {
+      if (d instanceof Error && d.message.includes("404"))
+        return false;
+      throw d;
+    }
+  }
+}
+
+// ../sdk/dist/api/commits.js
+class g {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  list(b, d) {
+    return this.client.get(`/repos/${b}/${d}/commits`);
+  }
+  get(b, d, f) {
+    return this.client.get(`/repos/${b}/${d}/commits/${f}`);
+  }
+  create(b, d, f) {
+    return this.client.post(`/repos/${b}/${d}/git/commits`, f);
+  }
+}
+
+// ../sdk/dist/api/actions.js
+class v {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  listOrgRunners(b) {
+    return this.client.get(`/orgs/${b}/actions/runners`);
+  }
+  createOrgRegistrationToken(b) {
+    return this.client.post(`/orgs/${b}/actions/runners/registration-token`, {});
+  }
+  getOrgRunner(b, h) {
+    return this.client.get(`/orgs/${b}/actions/runners/${h}`);
+  }
+  deleteOrgRunner(b, h) {
+    return this.client.delete(`/orgs/${b}/actions/runners/${h}`);
+  }
+  listRepoRunners(b, h) {
+    return this.client.get(`/repos/${b}/${h}/actions/runners`);
+  }
+  createRepoRegistrationToken(b, h) {
+    return this.client.post(`/repos/${b}/${h}/actions/runners/registration-token`, {});
+  }
+  getRepoRunner(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/runners/${j2}`);
+  }
+  deleteRepoRunner(b, h, j2) {
+    return this.client.delete(`/repos/${b}/${h}/actions/runners/${j2}`);
+  }
+  listOrgSecrets(b) {
+    return this.client.get(`/orgs/${b}/actions/secrets`);
+  }
+  getOrgSecret(b, h) {
+    return this.client.get(`/orgs/${b}/actions/secrets/${h}`);
+  }
+  createOrUpdateOrgSecret(b, h, j2) {
+    return this.client.put(`/orgs/${b}/actions/secrets/${h}`, j2);
+  }
+  deleteOrgSecret(b, h) {
+    return this.client.delete(`/orgs/${b}/actions/secrets/${h}`);
+  }
+  listRepoSecrets(b, h) {
+    return this.client.get(`/repos/${b}/${h}/actions/secrets`);
+  }
+  getRepoSecret(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/secrets/${j2}`);
+  }
+  createOrUpdateRepoSecret(b, h, j2, q) {
+    return this.client.put(`/repos/${b}/${h}/actions/secrets/${j2}`, q);
+  }
+  deleteRepoSecret(b, h, j2) {
+    return this.client.delete(`/repos/${b}/${h}/actions/secrets/${j2}`);
+  }
+  listOrgVariables(b) {
+    return this.client.get(`/orgs/${b}/actions/variables`);
+  }
+  createOrgVariable(b, h) {
+    return this.client.post(`/orgs/${b}/actions/variables`, h);
+  }
+  getOrgVariable(b, h) {
+    return this.client.get(`/orgs/${b}/actions/variables/${h}`);
+  }
+  deleteOrgVariable(b, h) {
+    return this.client.delete(`/orgs/${b}/actions/variables/${h}`);
+  }
+  updateOrgVariable(b, h, j2) {
+    return this.client.patch(`/orgs/${b}/actions/variables/${h}`, j2);
+  }
+  listRepoVariables(b, h) {
+    return this.client.get(`/repos/${b}/${h}/actions/variables`);
+  }
+  createRepoVariable(b, h, j2) {
+    return this.client.post(`/repos/${b}/${h}/actions/variables`, j2);
+  }
+  getRepoVariable(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/variables/${j2}`);
+  }
+  deleteRepoVariable(b, h, j2) {
+    return this.client.delete(`/repos/${b}/${h}/actions/variables/${j2}`);
+  }
+  updateRepoVariable(b, h, j2, q) {
+    return this.client.patch(`/repos/${b}/${h}/actions/variables/${j2}`, q);
+  }
+  listArtifacts(b, h) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts`);
+  }
+  getArtifact(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}`);
+  }
+  deleteArtifact(b, h, j2) {
+    return this.client.delete(`/repos/${b}/${h}/actions/artifacts/${j2}`);
+  }
+  downloadArtifact(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}/zip`);
+  }
+  downloadArtifactRaw(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}/zip/raw`);
+  }
+  getWorkflowDispatchInputs(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/workflows/${j2}/dispatches`);
+  }
+  dispatchWorkflow(b, h, j2, q) {
+    return this.client.post(`/repos/${b}/${h}/actions/workflows/${j2}/dispatches`, q);
+  }
+}
+
+// ../sdk/dist/errors.js
+class j2 extends Error {
+  status;
+  metadata;
+  constructor(b, f, h) {
+    super(f);
+    this.name = "GitVerseApiError", this.status = b, this.metadata = h, Object.setPrototypeOf(this, j2.prototype);
+  }
+}
+
+class k extends j2 {
+  rateLimit;
+  constructor(b, f, h) {
+    super(429, b, h);
+    this.name = "RateLimitError", this.rateLimit = f, Object.setPrototypeOf(this, k.prototype);
+  }
+  getRetryAfterSeconds() {
+    return this.rateLimit.retryAfter;
+  }
+  getResetDate() {
+    return new Date(this.rateLimit.reset * 1000);
+  }
+}
+
+class q {
+  currentVersion;
+  latestVersion;
+  decommissioning;
+  constructor(b, f, h) {
+    this.currentVersion = b, this.latestVersion = f, this.decommissioning = h;
+  }
+  getMessage() {
+    let b = `Используется устаревшая версия API: ${this.currentVersion}. Последняя версия: ${this.latestVersion}.`;
+    if (this.decommissioning)
+      b += ` Версия будет выведена из эксплуатации: ${this.decommissioning}.`;
+    return b;
+  }
+}
+
+// ../sdk/dist/api/stars.js
+class j3 {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  list() {
+    return this.client.get("/user/starred");
+  }
+  async add(b, c) {
+    await this.client.put(`/user/starred/${b}/${c}`);
+  }
+  async check(b, c) {
+    try {
+      return await this.client.get(`/user/starred/${b}/${c}`), true;
+    } catch (f) {
+      if (f instanceof j2 && f.status === 404)
+        return false;
+      throw f;
+    }
+  }
+  async remove(b, c) {
+    await this.client.delete(`/user/starred/${b}/${c}`);
+  }
+}
+
+// ../sdk/dist/api/issues.js
+class A {
+  client;
+  constructor(c) {
+    this.client = c;
+  }
+  list(c, h, f) {
+    let j4 = new URLSearchParams;
+    if (f)
+      j4.append("state", f);
+    let k2 = j4.toString(), z = `/repos/${c}/${h}/issues${k2 ? `?${k2}` : ""}`;
+    return this.client.get(z);
+  }
+  get(c, h, f) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}`);
+  }
+  getComment(c, h, f) {
+    return this.client.get(`/repos/${c}/${h}/issues/comments/${f}`);
+  }
+  getComments(c, h, f) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}/comments`);
+  }
+  getLabels(c, h, f) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}/labels`);
+  }
+  getTimeline(c, h, f) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}/timeline`);
+  }
+}
+
+// ../sdk/dist/api/branches.js
+class f {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  list(b, d) {
+    return this.client.get(`/repos/${b}/${d}/branches`);
+  }
+}
+
+// ../sdk/dist/utils.js
+var z = /^([a-z][a-z0-9+.-]*:\/\/[^/]+)\/([a-z][a-z0-9+.-]*:\/\/.+)$/i;
+function E(j4) {
+  if (!j4)
+    return j4;
+  let k2 = j4.match(z);
+  if (k2?.[1] && k2?.[2]) {
+    let q2 = k2[1], v2 = k2[2];
+    if (v2.startsWith(q2))
+      return v2;
+  }
+  return j4;
+}
+function J(j4) {
+  let k2 = ["clone_url", "html_url", "url", "git_url", "mirror_url"], q2 = { ...j4 };
+  for (let v2 of k2)
+    if (typeof q2[v2] === "string")
+      q2[v2] = E(q2[v2]);
+  return q2;
+}
+
+// ../sdk/dist/api/repositories.js
+class z2 {
+  client;
+  constructor(g2) {
+    this.client = g2;
+  }
+  async get(g2, j4) {
+    let k2 = await this.client.get(`/repos/${g2}/${j4}`);
+    return J(k2);
+  }
+  delete(g2, j4) {
+    return this.client.delete(`/repos/${g2}/${j4}`);
+  }
+  async update(g2, j4, k2) {
+    let v2 = await this.client.patch(`/repos/${g2}/${j4}`, k2);
+    return J(v2);
+  }
+  compare(g2, j4, k2) {
+    return this.client.get(`/repos/${g2}/${j4}/compare/${k2}`);
+  }
+  getLanguages(g2, j4) {
+    return this.client.get(`/repos/${g2}/${j4}/languages`);
+  }
+  async listForAuthenticatedUser() {
+    return (await this.client.get("/user/repos")).map((j4) => J(j4));
+  }
+  async create(g2) {
+    let j4 = await this.client.post("/user/repos", g2);
+    return J(j4);
+  }
+}
+
+// ../sdk/dist/api/collaborators.js
+class h {
+  client;
+  constructor(d) {
+    this.client = d;
+  }
+  list(d, f2) {
+    return this.client.get(`/repos/${d}/${f2}/collaborators`);
+  }
+  add(d, f2, g2) {
+    return this.client.put(`/repos/${d}/${f2}/collaborators/${g2}`, {});
+  }
+}
+
+// ../sdk/dist/api/contents.js
+class j4 {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  get(b, d, f2) {
+    return this.client.get(`/repos/${b}/${d}/contents/${f2}`);
+  }
+  createFile(b, d, f2, g2) {
+    return this.client.put(`/repos/${b}/${d}/contents/${f2}`, g2);
+  }
+  updateFile(b, d, f2, g2) {
+    return this.client.put(`/repos/${b}/${d}/contents/${f2}`, g2);
+  }
+  deleteFile(b, d, f2, g2) {
+    return this.client.delete(`/repos/${b}/${d}/contents/${f2}`, g2);
+  }
+}
+
+// ../sdk/dist/api/teams.js
+class j5 {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  list(b) {
+    return this.client.get(`/orgs/${b}/teams`);
+  }
+  getInvitations(b, d) {
+    return this.client.get(`/orgs/${b}/teams/${d}/invitations`);
+  }
+  getMembers(b, d) {
+    return this.client.get(`/orgs/${b}/teams/${d}/members`);
+  }
+  addRepository(b, d, f2, h2) {
+    return this.client.put(`/orgs/${b}/teams/${d}/repos/${f2}/${h2}`, {});
+  }
+}
+
+// ../sdk/dist/api/git.js
+class g2 {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  createRef(b, d, f2) {
+    return this.client.post(`/repos/${b}/${d}/git/refs`, f2);
+  }
+  createTree(b, d, f2) {
+    return this.client.post(`/repos/${b}/${d}/git/trees`, f2);
+  }
+  getTree(b, d, f2) {
+    return this.client.get(`/repos/${b}/${d}/git/trees/${f2}`);
+  }
+}
+
+// ../sdk/dist/api/releases.js
+class k2 {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  list(b, f2) {
+    return this.client.get(`/repos/${b}/${f2}/releases`);
+  }
+  create(b, f2, h2) {
+    return this.client.post(`/repos/${b}/${f2}/releases`, h2);
+  }
+  getByTag(b, f2, h2) {
+    return this.client.get(`/repos/${b}/${f2}/releases/tags/${h2}`);
+  }
+  deleteByTag(b, f2, h2) {
+    return this.client.delete(`/repos/${b}/${f2}/releases/tags/${h2}`);
+  }
+  get(b, f2, h2) {
+    return this.client.get(`/repos/${b}/${f2}/releases/${h2}`);
+  }
+  delete(b, f2, h2) {
+    return this.client.delete(`/repos/${b}/${f2}/releases/${h2}`);
+  }
+  update(b, f2, h2, j6) {
+    return this.client.patch(`/repos/${b}/${f2}/releases/${h2}`, j6);
+  }
+  getAssets(b, f2, h2) {
+    return this.client.get(`/repos/${b}/${f2}/releases/${h2}/assets`);
+  }
+  uploadAsset(b, f2, h2, j6) {
+    return this.client.post(`/repos/${b}/${f2}/releases/${h2}/assets`, j6);
+  }
+  deleteAsset(b, f2, h2, j6) {
+    return this.client.delete(`/repos/${b}/${f2}/releases/${h2}/assets/${j6}`);
+  }
+}
+
+// ../sdk/dist/api/pulls.js
+class v2 {
+  client;
+  constructor(d) {
+    this.client = d;
+  }
+  create(d, g3, f2) {
+    return this.client.post(`/repos/${d}/${g3}/pulls`, f2);
+  }
+  get(d, g3, f2) {
+    return this.client.get(`/repos/${d}/${g3}/pulls/${f2}`);
+  }
+  list(d, g3, f2) {
+    let k3 = new URL(`/repos/${d}/${g3}/pulls`, "http://localhost");
+    if (f2)
+      k3.searchParams.set("state", f2);
+    return this.client.get(k3.href.replace("http://localhost", ""));
+  }
+  update(d, g3, f2, j6) {
+    return this.client.patch(`/repos/${d}/${g3}/pulls/${f2}`, j6);
+  }
+  getFiles(d, g3, f2) {
+    return this.client.get(`/repos/${d}/${g3}/pulls/${f2}/files`);
+  }
+  updateBranch(d, g3, f2) {
+    return this.client.put(`/repos/${d}/${g3}/pulls/${f2}/update-branch`, {});
+  }
+  getCommits(d, g3, f2) {
+    return this.client.get(`/repos/${d}/${g3}/pulls/${f2}/commits`);
+  }
+}
+
+// ../sdk/dist/api/forks.js
+class k3 {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  async create(b, g3, h2) {
+    let j6 = await this.client.post(`/repos/${b}/${g3}/forks`, h2);
+    return J(j6);
+  }
+}
+
+// ../sdk/dist/client.js
+var F = { DELETE: "DELETE", GET: "GET", PATCH: "PATCH", POST: "POST", PUT: "PUT" };
+
+class Y {
+  baseUrl;
+  token;
+  apiVersion;
+  onApiVersionWarning;
+  constructor(j6 = {}) {
+    this.baseUrl = j6.baseUrl || "https://api.gitverse.ru", this.token = j6.token, this.apiVersion = j6.apiVersion || "1";
+  }
+  setToken(j6) {
+    this.token = j6;
+  }
+  extractRateLimitInfo(j6) {
+    let q2 = j6.get("GitVerse-RateLimit-Limit"), x = j6.get("GitVerse-RateLimit-Remaining"), z3 = j6.get("GitVerse-RateLimit-Retry-After"), B = j6.get("Gitverse-Ratelimit-Reset");
+    if (!(q2 && x && z3 && B))
+      return;
+    return { limit: Number.parseInt(q2, 10), remaining: Number.parseInt(x, 10), reset: Number.parseInt(B, 10), retryAfter: Number.parseInt(z3, 10) };
+  }
+  extractApiVersionInfo(j6) {
+    let q2 = j6.get("Gitverse-Api-Version"), x = j6.get("Gitverse-Api-Latest-Version"), z3 = j6.get("Gitverse-Api-Deprecation") === "true", B = j6.get("Gitverse-Api-Decommissioning");
+    if (!(q2 && x))
+      return;
+    return { decommissioning: B || undefined, deprecated: z3, latestVersion: x, version: q2 };
+  }
+  extractMetadata(j6) {
+    let q2 = this.extractRateLimitInfo(j6), x = this.extractApiVersionInfo(j6);
+    if (x?.deprecated && this.onApiVersionWarning) {
+      let z3 = new q(x.version, x.latestVersion, x.decommissioning);
+      this.onApiVersionWarning(z3);
+    }
+    return { apiVersion: x, rateLimit: q2 };
+  }
+  async request(j6, q2, x) {
+    let z3 = j6.startsWith("/") ? j6.slice(1) : j6, B = `${this.baseUrl}/${z3}`, J2 = new Headers;
+    if (J2.set("Content-Type", "application/json"), J2.set("Accept", `application/vnd.gitverse.object+json; version=${this.apiVersion}`), this.token)
+      J2.set("Authorization", `Bearer ${this.token}`);
+    let X = { body: x ? JSON.stringify(x) : undefined, headers: J2, method: q2 }, D = await fetch(B, X), K = this.extractMetadata(D.headers), N;
+    try {
+      N = await D.json();
+    } catch {
+      N = undefined;
+    }
+    if (!D.ok) {
+      let O = N?.message || D.statusText;
+      if (D.status === 429 && K.rateLimit)
+        throw new k(O || "Превышен лимит запросов. Попробуйте позже.", K.rateLimit, K);
+      throw new j2(D.status, O, K);
+    }
+    return N;
+  }
+  get(j6) {
+    return this.request(j6, F.GET);
+  }
+  post(j6, q2) {
+    return this.request(j6, F.POST, q2);
+  }
+  put(j6, q2) {
+    return this.request(j6, F.PUT, q2);
+  }
+  delete(j6, q2) {
+    return this.request(j6, F.DELETE, q2);
+  }
+  patch(j6, q2) {
+    return this.request(j6, F.PATCH, q2);
+  }
+}
+
+// ../sdk/dist/api/users.js
+class d {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  getCurrent() {
+    return this.client.get("/user");
+  }
+  getByUsername(b) {
+    return this.client.get(`/users/${b}`);
+  }
+}
+
+// ../sdk/dist/api/emails.js
+class c {
+  client;
+  constructor(b) {
+    this.client = b;
+  }
+  list() {
+    return this.client.get("/user/emails");
+  }
+  add(b) {
+    return this.client.post("/user/emails", b);
+  }
+  remove(b) {
+    return this.client.delete("/user/emails", b);
+  }
+}
+
+// ../sdk/dist/index.js
+class P {
+  client;
+  users;
+  repos;
+  contents;
+  pulls;
+  forks;
+  emails;
+  issues;
+  stars;
+  branches;
+  commits;
+  collaborators;
+  organizations;
+  teams;
+  releases;
+  git;
+  actions;
+  constructor(d2 = {}) {
+    this.client = new Y(d2), this.users = new d(this.client), this.repos = new z2(this.client), this.contents = new j4(this.client), this.pulls = new v2(this.client), this.forks = new k3(this.client), this.emails = new c(this.client), this.issues = new A(this.client), this.stars = new j3(this.client), this.branches = new f(this.client), this.commits = new g(this.client), this.collaborators = new h(this.client), this.organizations = new j(this.client), this.teams = new j5(this.client), this.releases = new k2(this.client), this.git = new g2(this.client), this.actions = new v(this.client);
+  }
+  setToken(d2) {
+    return this.client.setToken(d2), this;
+  }
+}
+
+// src/gitverse.ts
+class GitVerseReleaseClient {
+  client;
+  repoInfo;
+  constructor(token, repoInfo) {
+    this.client = new P({ token });
+    this.repoInfo = repoInfo;
+  }
+  async createRelease(tag, name, body, options = {}) {
+    const { owner, repo } = this.repoInfo;
+    try {
+      await this.client.releases.create(owner, repo, {
+        body,
+        draft: options.draft,
+        name,
+        prerelease: options.prerelease,
+        tag_name: tag
+      });
+      return `${this.repoInfo.url}/releases/tag/${tag}`;
+    } catch (error) {
+      throw new Error(`Failed to create GitVerse release: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async releaseExists(tag) {
+    const { owner, repo } = this.repoInfo;
+    try {
+      await this.client.releases.getByTag(owner, repo, tag);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getRelease(tag) {
+    const { owner, repo } = this.repoInfo;
+    return await this.client.releases.getByTag(owner, repo, tag);
+  }
+}
+function createGitVerseClient(repoInfo) {
+  const token = process.env.GITVERSE_TOKEN;
+  if (!token) {
+    throw new Error("GITVERSE_TOKEN environment variable is required for creating releases");
+  }
+  return new GitVerseReleaseClient(token, repoInfo);
+}
+
+// src/utils/changelog.ts
+import { readFile as readFile2, writeFile } from "node:fs/promises";
+
+// src/utils/parser.ts
+var COMMIT_REGEX = /^(?<type>\w+)(?:\((?<scope>[^)]+)\))?(?<breaking>!)?: (?<subject>.+)$/;
+function parseCommit(rawCommit) {
+  const lines = rawCommit.split(`
+`);
+  if (lines.length < 5) {
+    return null;
+  }
+  const [hash, shortHash, author, email, dateStr, ...messageLines] = lines;
+  if (!(hash && shortHash && author && email && dateStr)) {
+    return null;
+  }
+  const message = messageLines.join(`
+`).trim();
+  const messageParts = message.split(`
+`);
+  const firstLine = messageParts[0];
+  const bodyLines = messageParts.slice(1);
+  if (!firstLine) {
+    return null;
+  }
+  const match = firstLine.match(COMMIT_REGEX);
+  if (!match?.groups) {
+    return null;
+  }
+  const { type, scope, breaking, subject } = match.groups;
+  if (!(type && subject)) {
+    return null;
+  }
+  const body = bodyLines.join(`
+`).trim();
+  const hasBreakingInBody = body.includes("BREAKING CHANGE:") || body.includes("BREAKING-CHANGE:");
+  return {
+    author,
+    body: body || undefined,
+    breaking: !!breaking || hasBreakingInBody,
+    date: new Date(dateStr),
+    email,
+    footer: undefined,
+    hash,
+    raw: message,
+    scope: scope || undefined,
+    shortHash,
+    subject,
+    type
+  };
+}
+function parseCommits(rawCommits) {
+  return rawCommits.map((raw) => parseCommit(raw)).filter((commit) => commit !== null);
+}
+function groupCommitsByType(commits) {
+  const groups = {};
+  for (const commit of commits) {
+    if (!groups[commit.type]) {
+      groups[commit.type] = [];
+    }
+    groups[commit.type]?.push(commit);
+  }
+  return groups;
+}
+function hasBreakingChanges(commits) {
+  return commits.some((commit) => commit.breaking);
+}
+function hasFeatures(commits) {
+  return commits.some((commit) => commit.type === "feat");
+}
+function hasFixes(commits) {
+  return commits.some((commit) => commit.type === "fix");
+}
+
+// src/utils/changelog.ts
+function generateChangelog(options, config) {
+  const { version, commits, date = new Date, repoUrl } = options;
+  const sections = [];
+  const dateStr = date.toISOString().split("T")[0];
+  sections.push(`## [${version}] - ${dateStr}`);
+  sections.push("");
+  const grouped = groupCommitsByType(commits);
+  const typeOrder = ["feat", "fix", "perf", "refactor", "docs", "test", "build", "ci", "chore", "style", "revert"];
+  const breakingCommits = commits.filter((c2) => c2.breaking);
+  if (breakingCommits.length > 0) {
+    sections.push("### ⚠️ BREAKING CHANGES");
+    sections.push("");
+    for (const commit of breakingCommits) {
+      sections.push(formatCommit(commit, config, repoUrl));
+    }
+    sections.push("");
+  }
+  for (const type of typeOrder) {
+    const typeCommits = grouped[type]?.filter((c2) => !c2.breaking);
+    if (!typeCommits || typeCommits.length === 0) {
+      continue;
+    }
+    const title = config.types[type] || type.toUpperCase();
+    sections.push(`### ${title}`);
+    sections.push("");
+    for (const commit of typeCommits) {
+      sections.push(formatCommit(commit, config, repoUrl));
+    }
+    sections.push("");
+  }
+  return sections.join(`
+`);
+}
+function formatCommit(commit, config, repoUrl) {
+  const parts = [];
+  let message = commit.subject;
+  if (commit.scope) {
+    message = `**${commit.scope}:** ${message}`;
+  }
+  parts.push(`- ${message}`);
+  if (config.showHash && repoUrl) {
+    parts.push(`([${commit.shortHash}](${repoUrl}/commit/${commit.hash}))`);
+  } else if (config.showHash) {
+    parts.push(`(${commit.shortHash})`);
+  }
+  if (config.showAuthor) {
+    parts.push(`by @${commit.author}`);
+  }
+  return parts.join(" ");
+}
+async function updateChangelogFile(changelogPath, newEntry) {
+  let existingContent = "";
+  try {
+    existingContent = await readFile2(changelogPath, "utf-8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      existingContent = `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+`;
+    } else {
+      throw error;
+    }
+  }
+  const lines = existingContent.split(`
+`);
+  let insertIndex = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const currentLine = lines[i];
+    const prevLine = lines[i - 1];
+    if (currentLine?.startsWith("## ")) {
+      insertIndex = i;
+      break;
+    }
+    if (i > 0 && currentLine?.trim() === "" && prevLine?.trim() !== "") {
+      insertIndex = i + 1;
+    }
+  }
+  if (insertIndex === 0) {
+    insertIndex = lines.length;
+  }
+  lines.splice(insertIndex, 0, newEntry);
+  await writeFile(changelogPath, lines.join(`
+`));
+}
+function generateReleaseNotes(commits, config, repoUrl) {
+  const sections = [];
+  const breakingCommits = commits.filter((c2) => c2.breaking);
+  if (breakingCommits.length > 0) {
+    sections.push("⚠️ BREAKING CHANGES");
+    sections.push("");
+    for (const commit of breakingCommits) {
+      sections.push(formatCommit(commit, config, repoUrl));
+    }
+    sections.push("");
+  }
+  const grouped = groupCommitsByType(commits.filter((c2) => !c2.breaking));
+  const typeOrder = ["feat", "fix", "perf", "refactor", "docs", "test", "build", "ci", "chore", "style", "revert"];
+  for (const type of typeOrder) {
+    const typeCommits = grouped[type];
+    if (!typeCommits || typeCommits.length === 0) {
+      continue;
+    }
+    const title = config.types[type] || type.toUpperCase();
+    sections.push(title);
+    sections.push("");
+    for (const commit of typeCommits) {
+      sections.push(formatCommit(commit, config, repoUrl));
+    }
+    sections.push("");
+  }
+  return sections.join(`
+`).trim();
+}
+
+// src/utils/git.ts
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+var execAsync = promisify(exec);
+var GITVERSE_URL_REGEX_1 = /gitverse\.ru[:/]([^/]+)\/([^/.]+)(\.git)?$/;
+var GITVERSE_URL_REGEX_2 = /gitverse\.ru\/([^/]+)\/([^/.]+)(\.git)?$/;
+async function git(command) {
+  const { stdout } = await execAsync(`git ${command}`);
+  return stdout.trim();
+}
+async function getRepoInfo() {
+  if (process.env.GITVERSE_ACTIONS === "true" && process.env.GITHUB_REPOSITORY) {
+    const fullName = process.env.GITHUB_REPOSITORY;
+    const parts = fullName.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      const owner2 = parts[0];
+      const repo2 = parts[1];
+      const branch2 = process.env.GITHUB_REF_NAME || "main";
+      return {
+        branch: branch2,
+        fullName,
+        owner: owner2,
+        repo: repo2,
+        url: `https://gitverse.ru/${owner2}/${repo2}`
+      };
+    }
+  }
+  const url = await git("remote get-url origin");
+  const match = url.match(GITVERSE_URL_REGEX_1) || url.match(GITVERSE_URL_REGEX_2);
+  if (!(match?.[1] && match[2])) {
+    throw new Error(`Unable to parse GitVerse repository from URL: ${url}`);
+  }
+  const owner = match[1];
+  const repo = match[2];
+  const branch = await git("branch --show-current");
+  return {
+    branch,
+    fullName: `${owner}/${repo}`,
+    owner,
+    repo,
+    url: `https://gitverse.ru/${owner}/${repo}`
+  };
+}
+async function getLatestTag(prefix) {
+  try {
+    const tags = await git(`tag --sort=-v:refname --list "${prefix}*"`);
+    const tagList = tags.split(`
+`).filter((tag) => tag.length > 0);
+    return tagList.length > 0 ? tagList[0] ?? null : null;
+  } catch {
+    return null;
+  }
+}
+async function getCommitsSinceTag(tagPrefix, path) {
+  const latestTag = await getLatestTag(tagPrefix);
+  let range;
+  if (latestTag) {
+    range = `${latestTag}..HEAD`;
+  } else {
+    range = "HEAD";
+  }
+  const format = "%H%n%h%n%an%n%ae%n%ai%n%B%n==END==";
+  const pathFilter = path ? `-- ${path}` : "";
+  const log = await git(`log ${range} --format="${format}" ${pathFilter}`);
+  const commits = log.split(`
+==END==`).map((commit) => commit.trim()).filter((commit) => commit.length > 0 && commit !== "==END==");
+  return commits;
+}
+async function getCurrentVersion(packagePath) {
+  const { readFile: readFile3 } = await import("node:fs/promises");
+  const { resolve: resolve2 } = await import("node:path");
+  const pkgJsonPath = resolve2(packagePath, "package.json");
+  const content = await readFile3(pkgJsonPath, "utf-8");
+  const pkgJson = JSON.parse(content);
+  if (!pkgJson.version) {
+    throw new Error(`No version found in ${pkgJsonPath}`);
+  }
+  return pkgJson.version;
+}
+async function getPackageInfo(packagePath) {
+  const { readFile: readFile3 } = await import("node:fs/promises");
+  const { resolve: resolve2 } = await import("node:path");
+  const pkgJsonPath = resolve2(packagePath, "package.json");
+  const content = await readFile3(pkgJsonPath, "utf-8");
+  const pkgJson = JSON.parse(content);
+  if (!pkgJson.name) {
+    throw new Error(`No name found in ${pkgJsonPath}`);
+  }
+  if (!pkgJson.version) {
+    throw new Error(`No version found in ${pkgJsonPath}`);
+  }
+  return {
+    name: pkgJson.name,
+    version: pkgJson.version
+  };
+}
+async function updatePackageVersion(packagePath, newVersion) {
+  const { readFile: readFile3, writeFile: writeFile2 } = await import("node:fs/promises");
+  const { resolve: resolve2 } = await import("node:path");
+  const pkgJsonPath = resolve2(packagePath, "package.json");
+  const content = await readFile3(pkgJsonPath, "utf-8");
+  const pkgJson = JSON.parse(content);
+  pkgJson.version = newVersion;
+  await writeFile2(pkgJsonPath, `${JSON.stringify(pkgJson, null, 2)}
+`);
+}
+async function createCommit(message, files) {
+  for (const file of files) {
+    await git(`add "${file}"`);
+  }
+  await git(`commit -m "${message}"`);
+}
+async function createTag(tag, message) {
+  await git(`tag -a "${tag}" -m "${message}"`);
+}
+async function pushChanges(tag) {
+  await git("push");
+  if (tag) {
+    await git(`push origin "${tag}"`);
+  }
+}
+async function isWorkingTreeClean() {
+  try {
+    const status = await git("status --porcelain");
+    return status.length === 0;
+  } catch {
+    return false;
+  }
+}
+async function tagExists(tag) {
+  try {
+    await git(`rev-parse "${tag}"`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/version.ts
+var VERSION_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/;
+var PRERELEASE_INCREMENT_REGEX = /^(.+)\.(\d+)$/;
+function parseVersion(version) {
+  const v3 = version.startsWith("v") ? version.slice(1) : version;
+  const match = v3.match(VERSION_REGEX);
+  if (!(match?.[1] && match[2] && match[3])) {
+    throw new Error(`Invalid version format: ${version}`);
+  }
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    prerelease: match[4]
+  };
+}
+function formatVersion(ver) {
+  let result = `${ver.major}.${ver.minor}.${ver.patch}`;
+  if (ver.prerelease) {
+    result += `-${ver.prerelease}`;
+  }
+  return result;
+}
+function determineBumpType(commits) {
+  if (commits.length === 0) {
+    return null;
+  }
+  if (hasBreakingChanges(commits)) {
+    return "major";
+  }
+  if (hasFeatures(commits)) {
+    return "minor";
+  }
+  if (hasFixes(commits)) {
+    return "patch";
+  }
+  return "patch";
+}
+function bumpVersion(currentVersion, bumpType, prereleasePrefix) {
+  const ver = parseVersion(currentVersion);
+  switch (bumpType) {
+    case "major":
+      ver.major += 1;
+      ver.minor = 0;
+      ver.patch = 0;
+      ver.prerelease = undefined;
+      break;
+    case "minor":
+      ver.minor += 1;
+      ver.patch = 0;
+      ver.prerelease = undefined;
+      break;
+    case "patch":
+      ver.patch += 1;
+      ver.prerelease = undefined;
+      break;
+    case "prerelease":
+      if (ver.prerelease) {
+        const match = ver.prerelease.match(PRERELEASE_INCREMENT_REGEX);
+        if (match?.[1] && match[2]) {
+          const prefix = match[1];
+          const num = Number.parseInt(match[2], 10);
+          ver.prerelease = `${prefix}.${num + 1}`;
+        } else {
+          ver.prerelease = `${ver.prerelease}.1`;
+        }
+      } else {
+        ver.patch += 1;
+        ver.prerelease = `${prereleasePrefix || "beta"}.0`;
+      }
+      break;
+  }
+  return formatVersion(ver);
+}
+function calculateVersionBump(currentVersion, commits, forceVersion, prerelease) {
+  const bumpType = prerelease ? "prerelease" : determineBumpType(commits) || "patch";
+  const newVersion = forceVersion || bumpVersion(currentVersion, bumpType, prerelease);
+  return {
+    bumpType,
+    commits,
+    currentVersion,
+    hasBreaking: hasBreakingChanges(commits),
+    hasFeatures: hasFeatures(commits),
+    hasFixes: hasFixes(commits),
+    newVersion
+  };
+}
+
+// src/index.ts
+function printDryRunInfo(pkg, currentVersion, versionBump, tag, commits, changelogEntry) {
+  console.log(`
+\uD83D\uDD0D DRY RUN MODE - No changes will be made
+`);
+  console.log(`\uD83D\uDCE6 Package: ${pkg.packageName}`);
+  console.log(`\uD83D\uDCC8 Version: ${currentVersion} → ${versionBump.newVersion}`);
+  console.log(`\uD83C\uDFF7️  Tag: ${tag}`);
+  console.log(`\uD83D\uDCAC Commits: ${commits.length}`);
+  console.log(`
+\uD83D\uDCDD CHANGELOG:
+`);
+  console.log(changelogEntry);
+}
+function printSuccessInfo(pkg, currentVersion, newVersion, tag, releaseUrl) {
+  console.log(`
+✅ Release created successfully!
+`);
+  console.log(`\uD83D\uDCE6 Package: ${pkg.packageName}`);
+  console.log(`\uD83D\uDCC8 Version: ${currentVersion} → ${newVersion}`);
+  console.log(`\uD83C\uDFF7️  Tag: ${tag}`);
+  if (releaseUrl) {
+    console.log(`\uD83C\uDF10 Release: ${releaseUrl}`);
+  }
+  console.log("");
+}
+async function updatePackageFiles(pkg, newVersion, changelogEntry) {
+  await updatePackageVersion(pkg.path, newVersion);
+  const changelogPath = resolve2(pkg.path, pkg.changelog);
+  await updateChangelogFile(changelogPath, changelogEntry);
+  return changelogPath;
+}
+async function collectCommits(pkg, options, warnings) {
+  const rawCommits = await getCommitsSinceTag(pkg.tagPrefix, pkg.path);
+  if (rawCommits.length === 0 && !options.version) {
+    throw new Error(`No commits found since last release for ${pkg.packageName}`);
+  }
+  const commits = parseCommits(rawCommits);
+  if (commits.length === 0 && !options.version) {
+    warnings.push("No conventional commits found, but will proceed with patch bump");
+  }
+  return commits;
+}
+function resolvePrereleaseTag(options, config) {
+  if (typeof options.prerelease === "string") {
+    return options.prerelease;
+  }
+  if (options.prerelease) {
+    return config.versioning.prereleasePrefix;
+  }
+  return;
+}
+async function createGitVerseRelease(options, repoInfo, commits, config, pkg, versionBump, tag, warnings) {
+  if (options.noRelease) {
+    return;
+  }
+  try {
+    const gitverseClient = createGitVerseClient(repoInfo);
+    const releaseNotes = generateReleaseNotes(commits, config.changelog, repoInfo.url);
+    return await gitverseClient.createRelease(tag, `${pkg.packageName} v${versionBump.newVersion}`, releaseNotes, {
+      prerelease: !!options.prerelease
+    });
+  } catch (error) {
+    warnings.push(`Failed to create GitVerse release: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+}
+async function performGitOperations(config, options, pkg, newVersion, tag, changelogPath) {
+  if (config.git.commitChanges && !options.noCommit) {
+    const commitMessage = config.git.commitMessage.replace("{{package}}", pkg.name).replace("{{version}}", newVersion);
+    await createCommit(commitMessage, [resolve2(pkg.path, "package.json"), changelogPath]);
+  }
+  if (!options.noTag) {
+    const tagMessage = config.git.tagMessage.replace("{{package}}", pkg.name).replace("{{version}}", newVersion);
+    await createTag(tag, tagMessage);
+  }
+  if (config.git.push && !options.noPush) {
+    await pushChanges(options.noTag ? undefined : tag);
+  }
+}
+async function release(packageName, options = {}) {
+  const result = {
+    errors: [],
+    newVersion: "",
+    oldVersion: "",
+    packageName: packageName || "unknown",
+    success: false,
+    warnings: []
+  };
+  try {
+    const config = await loadConfig(options.config);
+    validateConfig(config);
+    const repoInfo = await getRepoInfo();
+    const pkg = await resolvePackage(config, packageName);
+    result.packageName = pkg.packageName;
+    if (!(options.dryRun || await isWorkingTreeClean())) {
+      throw new Error("Working tree is not clean. Please commit or stash your changes.");
+    }
+    const currentVersion = await getCurrentVersion(pkg.path);
+    result.oldVersion = currentVersion;
+    const commits = await collectCommits(pkg, options, result.warnings);
+    const prereleaseTag = resolvePrereleaseTag(options, config);
+    const versionBump = calculateVersionBump(currentVersion, commits, options.version, prereleaseTag);
+    result.newVersion = versionBump.newVersion;
+    const tag = `${pkg.tagPrefix}${versionBump.newVersion}`;
+    result.tag = tag;
+    if (await tagExists(tag)) {
+      throw new Error(`Tag ${tag} already exists`);
+    }
+    const changelogEntry = generateChangelog({
+      commits,
+      date: new Date,
+      repoUrl: repoInfo.url,
+      version: versionBump.newVersion
+    }, config.changelog);
+    if (options.dryRun) {
+      printDryRunInfo(pkg, currentVersion, versionBump, tag, commits, changelogEntry);
+      result.success = true;
+      return result;
+    }
+    const changelogPath = await updatePackageFiles(pkg, versionBump.newVersion, changelogEntry);
+    await performGitOperations(config, options, pkg, versionBump.newVersion, tag, changelogPath);
+    result.releaseUrl = await createGitVerseRelease(options, repoInfo, commits, config, pkg, versionBump, tag, result.warnings);
+    result.success = true;
+    printSuccessInfo(pkg, currentVersion, versionBump.newVersion, tag, result.releaseUrl);
+    return result;
+  } catch (error) {
+    result.success = false;
+    result.errors.push(error instanceof Error ? error.message : String(error));
+    console.error(`
+❌ Release failed:
+`);
+    console.error(error);
+    console.error("");
+    return result;
+  }
+}
+async function resolvePackage(config, packageName) {
+  if (!config.monorepo.enabled) {
+    const pkgInfo = await getPackageInfo(".");
+    return {
+      changelog: "CHANGELOG.md",
+      name: "main",
+      packageName: pkgInfo.name,
+      path: ".",
+      tagPrefix: config.versioning.tagPrefix
+    };
+  }
+  if (!packageName) {
+    throw new Error("Package name is required in monorepo mode. Use --package <name>");
+  }
+  const pkg = config.monorepo.packages.find((p) => p.name === packageName);
+  if (!pkg) {
+    throw new Error(`Package "${packageName}" not found in config. Available packages: ${config.monorepo.packages.map((p) => p.name).join(", ")}`);
+  }
+  return pkg;
+}
 
 // src/cli.ts
 import { parseArgs } from "node:util";
@@ -115,4 +1418,4 @@ async function main() {
 }
 main();
 
-//# debugId=24A29664F6808ADA64756E2164756E21
+//# debugId=6005E5D83DA9623E64756E2164756E21