gitverse-release 3.2.0 → 3.3.1

package/dist/cli.js

@@ -42,16 +42,36 @@ var DEFAULT_CONFIG = {
       test: "✅ Tests"
     }
   },
+  commitlint: {
+    comments: true,
+    format: "ts",
+    headerMaxLength: 100,
+    output: "commitlint.config.ts",
+    scopeRequired: false,
+    scopes: ["deps", "ci", "docs"]
+  },
   git: {
     commitChanges: true,
     commitMessage: "chore(release): {{package}} v{{version}} [skip ci]",
     push: true,
     tagMessage: "Release {{package}} v{{version}}"
   },
+  gitverse: {
+    checkExisting: true,
+    enabled: true,
+    failOnError: true
+  },
   monorepo: {
     enabled: false,
     packages: []
   },
+  retry: {
+    enabled: true,
+    initialDelay: 2000,
+    maxAttempts: 5,
+    maxDelay: 30000,
+    operations: ["push", "createRelease"]
+  },
   versioning: {
     allowPrerelease: false,
     preMajorMode: "auto",
@@ -83,14 +103,26 @@ function mergeConfig(defaults, user) {
         ...user.changelog?.types
       }
     },
+    commitlint: {
+      ...defaults.commitlint,
+      ...user.commitlint
+    },
     git: {
       ...defaults.git,
       ...user.git
     },
+    gitverse: {
+      ...defaults.gitverse,
+      ...user.gitverse
+    },
     monorepo: {
       ...defaults.monorepo,
       ...user.monorepo
     },
+    retry: {
+      ...defaults.retry,
+      ...user.retry
+    },
     versioning: {
       ...defaults.versioning,
       ...user.versioning
@@ -109,14 +141,14 @@ function validateConfig(config) {
 }
 
 // ../sdk/dist/api/organizations.js
-class j {
+class k {
   client;
   constructor(b) {
     this.client = b;
   }
-  async checkMembership(b, h) {
+  async checkMembership(b, h, j) {
     try {
-      return await this.client.get(`/orgs/${b}/members/${h}`), true;
+      return await this.client.get(`/orgs/${b}/members/${h}`, j), true;
     } catch (d) {
       if (d instanceof Error && d.message.includes("404"))
         return false;
@@ -126,126 +158,126 @@ class j {
 }
 
 // ../sdk/dist/api/commits.js
-class g {
+class j {
   client;
   constructor(b) {
     this.client = b;
   }
-  list(b, d) {
-    return this.client.get(`/repos/${b}/${d}/commits`);
+  list(b, d, f) {
+    return this.client.get(`/repos/${b}/${d}/commits`, f);
   }
-  get(b, d, f) {
-    return this.client.get(`/repos/${b}/${d}/commits/${f}`);
+  get(b, d, f, g) {
+    return this.client.get(`/repos/${b}/${d}/commits/${f}`, g);
   }
-  create(b, d, f) {
-    return this.client.post(`/repos/${b}/${d}/git/commits`, f);
+  create(b, d, f, g) {
+    return this.client.post(`/repos/${b}/${d}/git/commits`, f, g);
   }
 }
 
 // ../sdk/dist/api/actions.js
-class v {
+class x {
   client;
   constructor(b) {
     this.client = b;
   }
-  listOrgRunners(b) {
-    return this.client.get(`/orgs/${b}/actions/runners`);
+  listOrgRunners(b, h) {
+    return this.client.get(`/orgs/${b}/actions/runners`, h);
   }
-  createOrgRegistrationToken(b) {
-    return this.client.post(`/orgs/${b}/actions/runners/registration-token`, {});
+  createOrgRegistrationToken(b, h) {
+    return this.client.post(`/orgs/${b}/actions/runners/registration-token`, {}, h);
   }
-  getOrgRunner(b, h) {
-    return this.client.get(`/orgs/${b}/actions/runners/${h}`);
+  getOrgRunner(b, h, j2) {
+    return this.client.get(`/orgs/${b}/actions/runners/${h}`, j2);
   }
-  deleteOrgRunner(b, h) {
-    return this.client.delete(`/orgs/${b}/actions/runners/${h}`);
+  deleteOrgRunner(b, h, j2) {
+    return this.client.delete(`/orgs/${b}/actions/runners/${h}`, undefined, j2);
   }
-  listRepoRunners(b, h) {
-    return this.client.get(`/repos/${b}/${h}/actions/runners`);
+  listRepoRunners(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/runners`, j2);
   }
-  createRepoRegistrationToken(b, h) {
-    return this.client.post(`/repos/${b}/${h}/actions/runners/registration-token`, {});
+  createRepoRegistrationToken(b, h, j2) {
+    return this.client.post(`/repos/${b}/${h}/actions/runners/registration-token`, {}, j2);
   }
-  getRepoRunner(b, h, j2) {
-    return this.client.get(`/repos/${b}/${h}/actions/runners/${j2}`);
+  getRepoRunner(b, h, j2, q) {
+    return this.client.get(`/repos/${b}/${h}/actions/runners/${j2}`, q);
   }
-  deleteRepoRunner(b, h, j2) {
-    return this.client.delete(`/repos/${b}/${h}/actions/runners/${j2}`);
+  deleteRepoRunner(b, h, j2, q) {
+    return this.client.delete(`/repos/${b}/${h}/actions/runners/${j2}`, undefined, q);
   }
-  listOrgSecrets(b) {
-    return this.client.get(`/orgs/${b}/actions/secrets`);
+  listOrgSecrets(b, h) {
+    return this.client.get(`/orgs/${b}/actions/secrets`, h);
   }
-  getOrgSecret(b, h) {
-    return this.client.get(`/orgs/${b}/actions/secrets/${h}`);
+  getOrgSecret(b, h, j2) {
+    return this.client.get(`/orgs/${b}/actions/secrets/${h}`, j2);
   }
-  createOrUpdateOrgSecret(b, h, j2) {
-    return this.client.put(`/orgs/${b}/actions/secrets/${h}`, j2);
+  createOrUpdateOrgSecret(b, h, j2, q) {
+    return this.client.put(`/orgs/${b}/actions/secrets/${h}`, j2, q);
   }
-  deleteOrgSecret(b, h) {
-    return this.client.delete(`/orgs/${b}/actions/secrets/${h}`);
+  deleteOrgSecret(b, h, j2) {
+    return this.client.delete(`/orgs/${b}/actions/secrets/${h}`, undefined, j2);
   }
-  listRepoSecrets(b, h) {
-    return this.client.get(`/repos/${b}/${h}/actions/secrets`);
+  listRepoSecrets(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/secrets`, j2);
   }
-  getRepoSecret(b, h, j2) {
-    return this.client.get(`/repos/${b}/${h}/actions/secrets/${j2}`);
+  getRepoSecret(b, h, j2, q) {
+    return this.client.get(`/repos/${b}/${h}/actions/secrets/${j2}`, q);
   }
-  createOrUpdateRepoSecret(b, h, j2, q) {
-    return this.client.put(`/repos/${b}/${h}/actions/secrets/${j2}`, q);
+  createOrUpdateRepoSecret(b, h, j2, q, v) {
+    return this.client.put(`/repos/${b}/${h}/actions/secrets/${j2}`, q, v);
   }
-  deleteRepoSecret(b, h, j2) {
-    return this.client.delete(`/repos/${b}/${h}/actions/secrets/${j2}`);
+  deleteRepoSecret(b, h, j2, q) {
+    return this.client.delete(`/repos/${b}/${h}/actions/secrets/${j2}`, undefined, q);
   }
-  listOrgVariables(b) {
-    return this.client.get(`/orgs/${b}/actions/variables`);
+  listOrgVariables(b, h) {
+    return this.client.get(`/orgs/${b}/actions/variables`, h);
   }
-  createOrgVariable(b, h) {
-    return this.client.post(`/orgs/${b}/actions/variables`, h);
+  createOrgVariable(b, h, j2) {
+    return this.client.post(`/orgs/${b}/actions/variables`, h, j2);
   }
-  getOrgVariable(b, h) {
-    return this.client.get(`/orgs/${b}/actions/variables/${h}`);
+  getOrgVariable(b, h, j2) {
+    return this.client.get(`/orgs/${b}/actions/variables/${h}`, j2);
   }
-  deleteOrgVariable(b, h) {
-    return this.client.delete(`/orgs/${b}/actions/variables/${h}`);
+  deleteOrgVariable(b, h, j2) {
+    return this.client.delete(`/orgs/${b}/actions/variables/${h}`, undefined, j2);
   }
-  updateOrgVariable(b, h, j2) {
-    return this.client.patch(`/orgs/${b}/actions/variables/${h}`, j2);
+  updateOrgVariable(b, h, j2, q) {
+    return this.client.patch(`/orgs/${b}/actions/variables/${h}`, j2, q);
   }
-  listRepoVariables(b, h) {
-    return this.client.get(`/repos/${b}/${h}/actions/variables`);
+  listRepoVariables(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/variables`, j2);
   }
-  createRepoVariable(b, h, j2) {
-    return this.client.post(`/repos/${b}/${h}/actions/variables`, j2);
+  createRepoVariable(b, h, j2, q) {
+    return this.client.post(`/repos/${b}/${h}/actions/variables`, j2, q);
   }
-  getRepoVariable(b, h, j2) {
-    return this.client.get(`/repos/${b}/${h}/actions/variables/${j2}`);
+  getRepoVariable(b, h, j2, q) {
+    return this.client.get(`/repos/${b}/${h}/actions/variables/${j2}`, q);
   }
-  deleteRepoVariable(b, h, j2) {
-    return this.client.delete(`/repos/${b}/${h}/actions/variables/${j2}`);
+  deleteRepoVariable(b, h, j2, q) {
+    return this.client.delete(`/repos/${b}/${h}/actions/variables/${j2}`, undefined, q);
   }
-  updateRepoVariable(b, h, j2, q) {
-    return this.client.patch(`/repos/${b}/${h}/actions/variables/${j2}`, q);
+  updateRepoVariable(b, h, j2, q, v) {
+    return this.client.patch(`/repos/${b}/${h}/actions/variables/${j2}`, q, v);
   }
-  listArtifacts(b, h) {
-    return this.client.get(`/repos/${b}/${h}/actions/artifacts`);
+  listArtifacts(b, h, j2) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts`, j2);
   }
-  getArtifact(b, h, j2) {
-    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}`);
+  getArtifact(b, h, j2, q) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}`, q);
   }
-  deleteArtifact(b, h, j2) {
-    return this.client.delete(`/repos/${b}/${h}/actions/artifacts/${j2}`);
+  deleteArtifact(b, h, j2, q) {
+    return this.client.delete(`/repos/${b}/${h}/actions/artifacts/${j2}`, undefined, q);
   }
-  downloadArtifact(b, h, j2) {
-    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}/zip`);
+  downloadArtifact(b, h, j2, q) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}/zip`, q);
   }
-  downloadArtifactRaw(b, h, j2) {
-    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}/zip/raw`);
+  downloadArtifactRaw(b, h, j2, q) {
+    return this.client.get(`/repos/${b}/${h}/actions/artifacts/${j2}/zip/raw`, q);
   }
-  getWorkflowDispatchInputs(b, h, j2) {
-    return this.client.get(`/repos/${b}/${h}/actions/workflows/${j2}/dispatches`);
+  getWorkflowDispatchInputs(b, h, j2, q) {
+    return this.client.get(`/repos/${b}/${h}/actions/workflows/${j2}/dispatches`, q);
   }
-  dispatchWorkflow(b, h, j2, q) {
-    return this.client.post(`/repos/${b}/${h}/actions/workflows/${j2}/dispatches`, q);
+  dispatchWorkflow(b, h, j2, q, v) {
+    return this.client.post(`/repos/${b}/${h}/actions/workflows/${j2}/dispatches`, q, v);
   }
 }
 
@@ -259,11 +291,11 @@ class j2 extends Error {
   }
 }
 
-class k extends j2 {
+class k2 extends j2 {
   rateLimit;
   constructor(b, f, h) {
     super(429, b, h);
-    this.name = "RateLimitError", this.rateLimit = f, Object.setPrototypeOf(this, k.prototype);
+    this.name = "RateLimitError", this.rateLimit = f, Object.setPrototypeOf(this, k2.prototype);
   }
   getRetryAfterSeconds() {
     return this.rateLimit.retryAfter;
@@ -289,389 +321,387 @@ class q {
 }
 
 // ../sdk/dist/api/stars.js
-class j3 {
+class k3 {
   client;
   constructor(b) {
     this.client = b;
   }
-  list() {
-    return this.client.get("/user/starred");
+  list(b) {
+    return this.client.get("/user/starred", b);
   }
-  async add(b, c) {
-    await this.client.put(`/user/starred/${b}/${c}`);
+  async add(b, c, f) {
+    await this.client.put(`/user/starred/${b}/${c}`, undefined, f);
   }
-  async check(b, c) {
+  async check(b, c, f) {
     try {
-      return await this.client.get(`/user/starred/${b}/${c}`), true;
-    } catch (f) {
-      if (f instanceof j2 && f.status === 404)
+      return await this.client.get(`/user/starred/${b}/${c}`, f), true;
+    } catch (h) {
+      if (h instanceof j2 && h.status === 404)
         return false;
-      throw f;
+      throw h;
     }
   }
-  async remove(b, c) {
-    await this.client.delete(`/user/starred/${b}/${c}`);
+  async remove(b, c, f) {
+    await this.client.delete(`/user/starred/${b}/${c}`, undefined, f);
   }
 }
 
 // ../sdk/dist/api/issues.js
-class A {
+class B {
   client;
   constructor(c) {
     this.client = c;
   }
-  list(c, h, f) {
-    let j4 = new URLSearchParams;
+  list(c, h, f, j3) {
+    let k4 = new URLSearchParams;
     if (f)
-      j4.append("state", f);
-    let k2 = j4.toString(), z = `/repos/${c}/${h}/issues${k2 ? `?${k2}` : ""}`;
-    return this.client.get(z);
+      k4.append("state", f);
+    let z = k4.toString(), A = `/repos/${c}/${h}/issues${z ? `?${z}` : ""}`;
+    return this.client.get(A, j3);
   }
-  get(c, h, f) {
-    return this.client.get(`/repos/${c}/${h}/issues/${f}`);
+  get(c, h, f, j3) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}`, j3);
   }
-  getComment(c, h, f) {
-    return this.client.get(`/repos/${c}/${h}/issues/comments/${f}`);
+  getComment(c, h, f, j3) {
+    return this.client.get(`/repos/${c}/${h}/issues/comments/${f}`, j3);
   }
-  getComments(c, h, f) {
-    return this.client.get(`/repos/${c}/${h}/issues/${f}/comments`);
+  getComments(c, h, f, j3) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}/comments`, j3);
   }
-  getLabels(c, h, f) {
-    return this.client.get(`/repos/${c}/${h}/issues/${f}/labels`);
+  getLabels(c, h, f, j3) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}/labels`, j3);
   }
-  getTimeline(c, h, f) {
-    return this.client.get(`/repos/${c}/${h}/issues/${f}/timeline`);
+  getTimeline(c, h, f, j3) {
+    return this.client.get(`/repos/${c}/${h}/issues/${f}/timeline`, j3);
   }
 }
 
 // ../sdk/dist/api/branches.js
-class f {
+class g {
   client;
   constructor(b) {
     this.client = b;
   }
-  list(b, d) {
-    return this.client.get(`/repos/${b}/${d}/branches`);
+  list(b, d, f) {
+    return this.client.get(`/repos/${b}/${d}/branches`, f);
   }
 }
 
 // ../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]);
+function E(j3) {
+  if (!j3)
+    return j3;
+  let k4 = j3.match(z);
+  if (k4?.[1] && k4?.[2]) {
+    let q2 = k4[1], v = k4[2];
+    if (v.startsWith(q2))
+      return v;
+  }
+  return j3;
+}
+function J(j3) {
+  let k4 = ["clone_url", "html_url", "url", "git_url", "mirror_url"], q2 = { ...j3 };
+  for (let v of k4)
+    if (typeof q2[v] === "string")
+      q2[v] = E(q2[v]);
   return q2;
 }
 
 // ../sdk/dist/api/repositories.js
-class z2 {
+class A {
   client;
   constructor(g2) {
     this.client = g2;
   }
-  async get(g2, j4) {
-    let k2 = await this.client.get(`/repos/${g2}/${j4}`);
-    return J(k2);
+  async get(g2, k4, j3) {
+    let q2 = await this.client.get(`/repos/${g2}/${k4}`, j3);
+    return J(q2);
   }
-  delete(g2, j4) {
-    return this.client.delete(`/repos/${g2}/${j4}`);
+  delete(g2, k4, j3) {
+    return this.client.delete(`/repos/${g2}/${k4}`, undefined, j3);
   }
-  async update(g2, j4, k2) {
-    let v2 = await this.client.patch(`/repos/${g2}/${j4}`, k2);
-    return J(v2);
+  async update(g2, k4, j3, q2) {
+    let z2 = await this.client.patch(`/repos/${g2}/${k4}`, j3, q2);
+    return J(z2);
   }
-  compare(g2, j4, k2) {
-    return this.client.get(`/repos/${g2}/${j4}/compare/${k2}`);
+  compare(g2, k4, j3, q2) {
+    return this.client.get(`/repos/${g2}/${k4}/compare/${j3}`, q2);
   }
-  getLanguages(g2, j4) {
-    return this.client.get(`/repos/${g2}/${j4}/languages`);
+  getLanguages(g2, k4, j3) {
+    return this.client.get(`/repos/${g2}/${k4}/languages`, j3);
   }
-  async listForAuthenticatedUser() {
-    return (await this.client.get("/user/repos")).map((j4) => J(j4));
+  async listForAuthenticatedUser(g2) {
+    return (await this.client.get("/user/repos", g2)).map((j3) => J(j3));
   }
-  async create(g2) {
-    let j4 = await this.client.post("/user/repos", g2);
-    return J(j4);
+  async create(g2, k4) {
+    let j3 = await this.client.post("/user/repos", g2, k4);
+    return J(j3);
   }
 }
 
 // ../sdk/dist/api/collaborators.js
-class h {
+class j3 {
   client;
   constructor(d) {
     this.client = d;
   }
-  list(d, f2) {
-    return this.client.get(`/repos/${d}/${f2}/collaborators`);
+  list(d, f, g2) {
+    return this.client.get(`/repos/${d}/${f}/collaborators`, g2);
   }
-  add(d, f2, g2) {
-    return this.client.put(`/repos/${d}/${f2}/collaborators/${g2}`, {});
+  add(d, f, g2, h) {
+    return this.client.put(`/repos/${d}/${f}/collaborators/${g2}`, {}, h);
   }
 }
 
 // ../sdk/dist/api/contents.js
-class j4 {
+class k4 {
   client;
   constructor(b) {
     this.client = b;
   }
-  get(b, d, f2) {
-    return this.client.get(`/repos/${b}/${d}/contents/${f2}`);
+  get(b, d, f, g2) {
+    return this.client.get(`/repos/${b}/${d}/contents/${f}`, g2);
   }
-  createFile(b, d, f2, g2) {
-    return this.client.put(`/repos/${b}/${d}/contents/${f2}`, g2);
+  createFile(b, d, f, g2, j4) {
+    return this.client.put(`/repos/${b}/${d}/contents/${f}`, g2, j4);
   }
-  updateFile(b, d, f2, g2) {
-    return this.client.put(`/repos/${b}/${d}/contents/${f2}`, g2);
+  updateFile(b, d, f, g2, j4) {
+    return this.client.put(`/repos/${b}/${d}/contents/${f}`, g2, j4);
   }
-  deleteFile(b, d, f2, g2) {
-    return this.client.delete(`/repos/${b}/${d}/contents/${f2}`, g2);
+  deleteFile(b, d, f, g2, j4) {
+    return this.client.delete(`/repos/${b}/${d}/contents/${f}`, g2, j4);
   }
 }
 
 // ../sdk/dist/api/teams.js
-class j5 {
+class k5 {
   client;
   constructor(b) {
     this.client = b;
   }
-  list(b) {
-    return this.client.get(`/orgs/${b}/teams`);
+  list(b, d) {
+    return this.client.get(`/orgs/${b}/teams`, d);
   }
-  getInvitations(b, d) {
-    return this.client.get(`/orgs/${b}/teams/${d}/invitations`);
+  getInvitations(b, d, f) {
+    return this.client.get(`/orgs/${b}/teams/${d}/invitations`, f);
   }
-  getMembers(b, d) {
-    return this.client.get(`/orgs/${b}/teams/${d}/members`);
+  getMembers(b, d, f) {
+    return this.client.get(`/orgs/${b}/teams/${d}/members`, f);
   }
-  addRepository(b, d, f2, h2) {
-    return this.client.put(`/orgs/${b}/teams/${d}/repos/${f2}/${h2}`, {});
+  addRepository(b, d, f, h, j4) {
+    return this.client.put(`/orgs/${b}/teams/${d}/repos/${f}/${h}`, {}, j4);
   }
 }
 
 // ../sdk/dist/api/git.js
-class g2 {
+class j4 {
   client;
   constructor(b) {
     this.client = b;
   }
-  createRef(b, d, f2) {
-    return this.client.post(`/repos/${b}/${d}/git/refs`, f2);
+  createRef(b, d, f, g2) {
+    return this.client.post(`/repos/${b}/${d}/git/refs`, f, g2);
   }
-  createTree(b, d, f2) {
-    return this.client.post(`/repos/${b}/${d}/git/trees`, f2);
+  createTree(b, d, f, g2) {
+    return this.client.post(`/repos/${b}/${d}/git/trees`, f, g2);
   }
-  getTree(b, d, f2) {
-    return this.client.get(`/repos/${b}/${d}/git/trees/${f2}`);
+  getTree(b, d, f, g2) {
+    return this.client.get(`/repos/${b}/${d}/git/trees/${f}`, g2);
   }
 }
 
 // ../sdk/dist/api/releases.js
-class k2 {
+class q2 {
   client;
   constructor(b) {
     this.client = b;
   }
-  list(b, f2) {
-    return this.client.get(`/repos/${b}/${f2}/releases`);
+  list(b, f, h) {
+    return this.client.get(`/repos/${b}/${f}/releases`, h);
   }
-  create(b, f2, h2) {
-    return this.client.post(`/repos/${b}/${f2}/releases`, h2);
+  create(b, f, h, j5) {
+    return this.client.post(`/repos/${b}/${f}/releases`, h, j5);
   }
-  getByTag(b, f2, h2) {
-    return this.client.get(`/repos/${b}/${f2}/releases/tags/${h2}`);
+  getByTag(b, f, h, j5) {
+    return this.client.get(`/repos/${b}/${f}/releases/tags/${h}`, j5);
   }
-  deleteByTag(b, f2, h2) {
-    return this.client.delete(`/repos/${b}/${f2}/releases/tags/${h2}`);
+  deleteByTag(b, f, h, j5) {
+    return this.client.delete(`/repos/${b}/${f}/releases/tags/${h}`, undefined, j5);
   }
-  get(b, f2, h2) {
-    return this.client.get(`/repos/${b}/${f2}/releases/${h2}`);
+  get(b, f, h, j5) {
+    return this.client.get(`/repos/${b}/${f}/releases/${h}`, j5);
   }
-  delete(b, f2, h2) {
-    return this.client.delete(`/repos/${b}/${f2}/releases/${h2}`);
+  delete(b, f, h, j5) {
+    return this.client.delete(`/repos/${b}/${f}/releases/${h}`, undefined, j5);
   }
-  update(b, f2, h2, j6) {
-    return this.client.patch(`/repos/${b}/${f2}/releases/${h2}`, j6);
+  update(b, f, h, j5, k6) {
+    return this.client.patch(`/repos/${b}/${f}/releases/${h}`, j5, k6);
   }
-  getAssets(b, f2, h2) {
-    return this.client.get(`/repos/${b}/${f2}/releases/${h2}/assets`);
+  getAssets(b, f, h, j5) {
+    return this.client.get(`/repos/${b}/${f}/releases/${h}/assets`, j5);
   }
-  uploadAsset(b, f2, h2, j6) {
-    return this.client.post(`/repos/${b}/${f2}/releases/${h2}/assets`, j6);
+  uploadAsset(b, f, h, j5, k6) {
+    return this.client.post(`/repos/${b}/${f}/releases/${h}/assets`, j5, k6);
   }
-  deleteAsset(b, f2, h2, j6) {
-    return this.client.delete(`/repos/${b}/${f2}/releases/${h2}/assets/${j6}`);
+  deleteAsset(b, f, h, j5, k6) {
+    return this.client.delete(`/repos/${b}/${f}/releases/${h}/assets/${j5}`, undefined, k6);
   }
 }
 
 // ../sdk/dist/api/pulls.js
-class v2 {
+class y {
   client;
   constructor(d) {
     this.client = d;
   }
-  create(d, g3, f2) {
-    return this.client.post(`/repos/${d}/${g3}/pulls`, f2);
+  create(d, f, g2, j5) {
+    return this.client.post(`/repos/${d}/${f}/pulls`, g2, j5);
   }
-  get(d, g3, f2) {
-    return this.client.get(`/repos/${d}/${g3}/pulls/${f2}`);
+  get(d, f, g2, j5) {
+    return this.client.get(`/repos/${d}/${f}/pulls/${g2}`, j5);
   }
-  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", ""));
+  list(d, f, g2, j5) {
+    let x2 = new URLSearchParams(Object.entries(g2 ?? {})), q3 = new URL(`/repos/${d}/${f}/pulls`, "http://localhost");
+    return q3.search = x2.toString(), this.client.get(q3.href.replace("http://localhost", ""), j5);
   }
-  update(d, g3, f2, j6) {
-    return this.client.patch(`/repos/${d}/${g3}/pulls/${f2}`, j6);
+  update(d, f, g2, j5, k6) {
+    return this.client.patch(`/repos/${d}/${f}/pulls/${g2}`, j5, k6);
   }
-  getFiles(d, g3, f2) {
-    return this.client.get(`/repos/${d}/${g3}/pulls/${f2}/files`);
+  getFiles(d, f, g2, j5) {
+    return this.client.get(`/repos/${d}/${f}/pulls/${g2}/files`, j5);
   }
-  updateBranch(d, g3, f2) {
-    return this.client.put(`/repos/${d}/${g3}/pulls/${f2}/update-branch`, {});
+  updateBranch(d, f, g2, j5) {
+    return this.client.put(`/repos/${d}/${f}/pulls/${g2}/update-branch`, {}, j5);
   }
-  getCommits(d, g3, f2) {
-    return this.client.get(`/repos/${d}/${g3}/pulls/${f2}/commits`);
+  getCommits(d, f, g2, j5) {
+    return this.client.get(`/repos/${d}/${f}/pulls/${g2}/commits`, j5);
   }
-  async checkIfMerged(d, g3, f2) {
+  async checkIfMerged(d, f, g2, j5) {
     try {
-      return await this.client.get(`/repos/${d}/${g3}/pulls/${f2}/merge`), true;
-    } catch (j6) {
-      if (j6 instanceof j2 && j6.status === 404)
+      return await this.client.get(`/repos/${d}/${f}/pulls/${g2}/merge`, j5), true;
+    } catch (k6) {
+      if (k6 instanceof j2 && k6.status === 404)
         return false;
-      throw j6;
+      throw k6;
     }
   }
 }
 
 // ../sdk/dist/api/forks.js
-class k3 {
+class q3 {
   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);
+  async create(b, g2, h, j5) {
+    let k6 = await this.client.post(`/repos/${b}/${g2}/forks`, h, j5);
+    return J(k6);
   }
 }
 
 // ../sdk/dist/client.js
 var F = { DELETE: "DELETE", GET: "GET", PATCH: "PATCH", POST: "POST", PUT: "PUT" };
 
-class Y {
+class _ {
   baseUrl;
   token;
   apiVersion;
   onApiVersionWarning;
-  constructor(j6 = {}) {
-    this.baseUrl = j6.baseUrl || "https://api.gitverse.ru", this.token = j6.token, this.apiVersion = j6.apiVersion || "1";
+  constructor(j5 = {}) {
+    this.baseUrl = j5.baseUrl || "https://api.gitverse.ru", this.token = j5.token, this.apiVersion = j5.apiVersion || "1";
   }
-  setToken(j6) {
-    this.token = j6;
+  setToken(j5) {
+    this.token = j5;
   }
-  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))
+  extractRateLimitInfo(j5) {
+    let x2 = j5.get("GitVerse-RateLimit-Limit"), q4 = j5.get("GitVerse-RateLimit-Remaining"), z2 = j5.get("GitVerse-RateLimit-Retry-After"), B2 = j5.get("Gitverse-Ratelimit-Reset");
+    if (!(x2 && q4 && z2 && B2))
       return;
-    return { limit: Number.parseInt(q2, 10), remaining: Number.parseInt(x, 10), reset: Number.parseInt(B, 10), retryAfter: Number.parseInt(z3, 10) };
+    return { limit: Number.parseInt(x2, 10), remaining: Number.parseInt(q4, 10), reset: Number.parseInt(B2, 10), retryAfter: Number.parseInt(z2, 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))
+  extractApiVersionInfo(j5) {
+    let x2 = j5.get("Gitverse-Api-Version"), q4 = j5.get("Gitverse-Api-Latest-Version"), z2 = j5.get("Gitverse-Api-Deprecation") === "true", B2 = j5.get("Gitverse-Api-Decommissioning");
+    if (!(x2 && q4))
       return;
-    return { decommissioning: B || undefined, deprecated: z3, latestVersion: x, version: q2 };
+    return { decommissioning: B2 || undefined, deprecated: z2, latestVersion: q4, version: x2 };
   }
-  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);
+  extractMetadata(j5) {
+    let x2 = this.extractRateLimitInfo(j5), q4 = this.extractApiVersionInfo(j5);
+    if (q4?.deprecated && this.onApiVersionWarning) {
+      let z2 = new q(q4.version, q4.latestVersion, q4.decommissioning);
+      this.onApiVersionWarning(z2);
     }
-    return { apiVersion: x, rateLimit: q2 };
+    return { apiVersion: q4, rateLimit: x2 };
   }
-  async request(j6, q2, x) {
-    let z3 = j6.startsWith("/") ? j6.slice(1) : j6, B = `${this.baseUrl}/${z3}`, J2 = new Headers;
+  async request(j5, x2, q4, z2) {
+    let B2 = j5.startsWith("/") ? j5.slice(1) : j5, Y = `${this.baseUrl}/${B2}`, 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;
+    let Z = { body: q4 ? JSON.stringify(q4) : undefined, headers: J2, method: x2, signal: z2?.signal }, D = await fetch(Y, Z), K = this.extractMetadata(D.headers), N;
     try {
       N = await D.json();
     } catch {
       N = undefined;
     }
     if (!D.ok) {
-      let O = N?.message || D.statusText;
+      let Q = N?.message || D.statusText;
       if (D.status === 429 && K.rateLimit)
-        throw new k(O || "Превышен лимит запросов. Попробуйте позже.", K.rateLimit, K);
-      throw new j2(D.status, O, K);
+        throw new k2(Q || "Превышен лимит запросов. Попробуйте позже.", K.rateLimit, K);
+      throw new j2(D.status, Q, K);
     }
     return N;
   }
-  get(j6) {
-    return this.request(j6, F.GET);
+  get(j5, x2) {
+    return this.request(j5, F.GET, undefined, x2);
   }
-  post(j6, q2) {
-    return this.request(j6, F.POST, q2);
+  post(j5, x2, q4) {
+    return this.request(j5, F.POST, x2, q4);
   }
-  put(j6, q2) {
-    return this.request(j6, F.PUT, q2);
+  put(j5, x2, q4) {
+    return this.request(j5, F.PUT, x2, q4);
   }
-  delete(j6, q2) {
-    return this.request(j6, F.DELETE, q2);
+  delete(j5, x2, q4) {
+    return this.request(j5, F.DELETE, x2, q4);
   }
-  patch(j6, q2) {
-    return this.request(j6, F.PATCH, q2);
+  patch(j5, x2, q4) {
+    return this.request(j5, F.PATCH, x2, q4);
   }
 }
 
 // ../sdk/dist/api/users.js
-class d {
+class f {
   client;
   constructor(b) {
     this.client = b;
   }
-  getCurrent() {
-    return this.client.get("/user");
+  getCurrent(b) {
+    return this.client.get("/user", b);
   }
-  getByUsername(b) {
-    return this.client.get(`/users/${b}`);
+  getByUsername(b, d) {
+    return this.client.get(`/users/${b}`, d);
   }
 }
 
 // ../sdk/dist/api/emails.js
-class c {
+class d {
   client;
   constructor(b) {
     this.client = b;
   }
-  list() {
-    return this.client.get("/user/emails");
+  list(b) {
+    return this.client.get("/user/emails", b);
   }
-  add(b) {
-    return this.client.post("/user/emails", b);
+  add(b, c) {
+    return this.client.post("/user/emails", b, c);
   }
-  remove(b) {
-    return this.client.delete("/user/emails", b);
+  remove(b, c) {
+    return this.client.delete("/user/emails", b, c);
   }
 }
 
 // ../sdk/dist/index.js
-class P {
+class Z {
   client;
   users;
   repos;
@@ -690,7 +720,7 @@ class P {
   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);
+    this.client = new _(d2), this.users = new f(this.client), this.repos = new A(this.client), this.contents = new k4(this.client), this.pulls = new y(this.client), this.forks = new q3(this.client), this.emails = new d(this.client), this.issues = new B(this.client), this.stars = new k3(this.client), this.branches = new g(this.client), this.commits = new j(this.client), this.collaborators = new j3(this.client), this.organizations = new k(this.client), this.teams = new k5(this.client), this.releases = new q2(this.client), this.git = new j4(this.client), this.actions = new x(this.client);
   }
   setToken(d2) {
     return this.client.setToken(d2), this;
@@ -701,24 +731,32 @@ class P {
 class GitVerseReleaseClient {
   client;
   repoInfo;
-  constructor(token, repoInfo) {
-    this.client = new P({ token });
+  retryFn;
+  constructor(token, repoInfo, retryFn) {
+    this.client = new Z({ token });
     this.repoInfo = repoInfo;
+    this.retryFn = retryFn;
   }
   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)}`);
+    const createFn = async () => {
+      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)}`);
+      }
+    };
+    if (this.retryFn) {
+      return await this.retryFn(createFn, "Create GitVerse Release");
     }
+    return await createFn();
   }
   async releaseExists(tag) {
     const { owner, repo } = this.repoInfo;
@@ -734,12 +772,12 @@ class GitVerseReleaseClient {
     return await this.client.releases.getByTag(owner, repo, tag);
   }
 }
-function createGitVerseClient(repoInfo) {
+function createGitVerseClient(repoInfo, retryFn) {
   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);
+  return new GitVerseReleaseClient(token, repoInfo, retryFn);
 }
 
 // src/utils/changelog.ts
@@ -816,7 +854,7 @@ function hasFixes(commits) {
 }
 
 // src/utils/changelog.ts
-function generateChangelog(options, config) {
+function generateChangelog(options, config, packageName) {
   const { version, commits, date = new Date, repoUrl } = options;
   const sections = [];
   const dateStr = date.toISOString().split("T")[0];
@@ -824,17 +862,17 @@ function generateChangelog(options, config) {
   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);
+  const breakingCommits = commits.filter((c) => c.breaking);
   if (breakingCommits.length > 0) {
     sections.push("### ⚠️ BREAKING CHANGES");
     sections.push("");
     for (const commit of breakingCommits) {
-      sections.push(formatCommit(commit, config, repoUrl));
+      sections.push(formatCommit(commit, config, repoUrl, packageName));
     }
     sections.push("");
   }
   for (const type of typeOrder) {
-    const typeCommits = grouped[type]?.filter((c2) => !c2.breaking);
+    const typeCommits = grouped[type]?.filter((c) => !c.breaking);
     if (!typeCommits || typeCommits.length === 0) {
       continue;
     }
@@ -842,17 +880,17 @@ function generateChangelog(options, config) {
     sections.push(`### ${title}`);
     sections.push("");
     for (const commit of typeCommits) {
-      sections.push(formatCommit(commit, config, repoUrl));
+      sections.push(formatCommit(commit, config, repoUrl, packageName));
     }
     sections.push("");
   }
   return sections.join(`
 `);
 }
-function formatCommit(commit, config, repoUrl) {
+function formatCommit(commit, config, repoUrl, packageName) {
   const parts = [];
   let message = commit.subject;
-  if (commit.scope) {
+  if (commit.scope && commit.scope !== packageName) {
     message = `**${commit.scope}:** ${message}`;
   }
   parts.push(`- ${message}`);
@@ -902,18 +940,18 @@ All notable changes to this project will be documented in this file.
   await writeFile(changelogPath, lines.join(`
 `));
 }
-function generateReleaseNotes(commits, config, repoUrl) {
+function generateReleaseNotes(commits, config, repoUrl, packageName) {
   const sections = [];
-  const breakingCommits = commits.filter((c2) => c2.breaking);
+  const breakingCommits = commits.filter((c) => c.breaking);
   if (breakingCommits.length > 0) {
     sections.push("⚠️ BREAKING CHANGES");
     sections.push("");
     for (const commit of breakingCommits) {
-      sections.push(formatCommit(commit, config, repoUrl));
+      sections.push(formatCommit(commit, config, repoUrl, packageName));
     }
     sections.push("");
   }
-  const grouped = groupCommitsByType(commits.filter((c2) => !c2.breaking));
+  const grouped = groupCommitsByType(commits.filter((c) => !c.breaking));
   const typeOrder = ["feat", "fix", "perf", "refactor", "docs", "test", "build", "ci", "chore", "style", "revert"];
   for (const type of typeOrder) {
     const typeCommits = grouped[type];
@@ -924,7 +962,7 @@ function generateReleaseNotes(commits, config, repoUrl) {
     sections.push(title);
     sections.push("");
     for (const commit of typeCommits) {
-      sections.push(formatCommit(commit, config, repoUrl));
+      sections.push(formatCommit(commit, config, repoUrl, packageName));
     }
     sections.push("");
   }
@@ -936,6 +974,27 @@ function generateReleaseNotes(commits, config, repoUrl) {
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
+async function executeCommand(command) {
+  const { stdout, stderr } = await execAsync(command);
+  if (stderr && !stderr.includes("warning")) {
+    console.warn(`Command stderr: ${stderr}`);
+  }
+  return stdout.trim();
+}
+async function runBeforeCommitHook(command) {
+  console.log(`
+\uD83D\uDD27 Running before-commit hook: ${command}`);
+  try {
+    await executeCommand(command);
+    console.log(`✅ Before-commit hook completed successfully
+`);
+    return true;
+  } catch (error) {
+    console.warn(`⚠️  Before-commit hook failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    return false;
+  }
+}
 var GITVERSE_URL_REGEX_1 = /gitverse\.ru[:/]([^/]+)\/([^/.]+)(\.git)?$/;
 var GITVERSE_URL_REGEX_2 = /gitverse\.ru\/([^/]+)\/([^/.]+)(\.git)?$/;
 async function git(command) {
@@ -1056,7 +1115,26 @@ async function pushChanges(tag) {
 async function isWorkingTreeClean() {
   try {
     const status = await git("status --porcelain");
-    return status.length === 0;
+    if (status.length === 0) {
+      return true;
+    }
+    const lines = status.split(`
+`).filter((line) => line.length > 0);
+    const unstagedChanges = lines.filter((line) => {
+      const workingTreeStatus = line[1];
+      return workingTreeStatus !== " ";
+    });
+    if (unstagedChanges.length > 0) {
+      console.log(`
+⚠️  Unstaged changes detected:`);
+      for (const line of unstagedChanges) {
+        console.log(`  ${line}`);
+      }
+      console.log("");
+      return false;
+    }
+    console.log("✓ Working tree clean (staged changes will be included in release commit)");
+    return true;
   } catch {
     return false;
   }
@@ -1070,12 +1148,77 @@ async function tagExists(tag) {
   }
 }
 
+// src/utils/retry.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function calculateDelay(attempt, initialDelay, maxDelay) {
+  const delay = initialDelay * 2 ** attempt;
+  return Math.min(delay, maxDelay);
+}
+function isRetriableError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  if (message.includes("network") || message.includes("timeout") || message.includes("econnreset")) {
+    return true;
+  }
+  if (message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504")) {
+    return true;
+  }
+  if (message.includes("rate limit") || message.includes("429")) {
+    return true;
+  }
+  return false;
+}
+async function retry(fn, options) {
+  const { maxAttempts, initialDelay, maxDelay, operationName = "Operation" } = options;
+  let lastError;
+  for (let attempt = 0;attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const canRetry = isRetriableError(error);
+      if (attempt === maxAttempts - 1 || !canRetry) {
+        if (!canRetry && attempt < maxAttempts - 1) {
+          console.error(`
+❌ ${operationName} failed with non-retriable error:`);
+          console.error(lastError.message);
+        }
+        throw lastError;
+      }
+      const delay = calculateDelay(attempt, initialDelay, maxDelay);
+      console.warn(`
+⚠️  ${operationName} failed (attempt ${attempt + 1}/${maxAttempts}):`);
+      console.warn(`   ${lastError.message}`);
+      console.warn(`   Retrying in ${delay}ms...`);
+      await sleep(delay);
+    }
+  }
+  throw lastError || new Error(`${operationName} failed after ${maxAttempts} attempts`);
+}
+function createRetryFunction(config) {
+  return async (fn, operationName) => {
+    if (!config.enabled) {
+      return await fn();
+    }
+    return await retry(fn, {
+      initialDelay: config.initialDelay,
+      maxAttempts: config.maxAttempts,
+      maxDelay: config.maxDelay,
+      operationName
+    });
+  };
+}
+
 // 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);
+  const v = version.startsWith("v") ? version.slice(1) : version;
+  const match = v.match(VERSION_REGEX);
   if (!(match?.[1] && match[2] && match[3])) {
     throw new Error(`Invalid version format: ${version}`);
   }
@@ -1241,10 +1384,11 @@ async function collectCommits(pkg, options, warnings) {
     throw new Error(`No commits found since last release for ${pkg.packageName}`);
   }
   const commits = parseCommits(rawCommits);
-  if (commits.length === 0 && !options.version) {
+  const filteredCommits = commits.filter((commit) => !commit.scope || commit.scope === pkg.name);
+  if (filteredCommits.length === 0 && !options.version) {
     warnings.push("No conventional commits found, but will proceed with patch bump");
   }
-  return commits;
+  return filteredCommits;
 }
 function resolvePrereleaseTag(options, config) {
   if (typeof options.prerelease === "string") {
@@ -1255,23 +1399,33 @@ function resolvePrereleaseTag(options, config) {
   }
   return;
 }
-async function createGitVerseRelease(options, repoInfo, commits, config, pkg, versionBump, tag, warnings) {
-  if (options.noRelease) {
+async function createGitVerseRelease(options, repoInfo, commits, config, pkg, versionBump, tag, retryFn) {
+  if (options.noRelease || !config.gitverse.enabled) {
     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;
+  const gitverseClient = createGitVerseClient(repoInfo, retryFn);
+  if (config.gitverse.checkExisting) {
+    const exists = await gitverseClient.releaseExists(tag);
+    if (exists) {
+      console.log(`
+✅ Release ${tag} already exists, skipping creation
+`);
+      return `${repoInfo.url}/releases/tag/${tag}`;
+    }
   }
+  const releaseNotes = generateReleaseNotes(commits, config.changelog, repoInfo.url, pkg.name);
+  return await gitverseClient.createRelease(tag, `${pkg.packageName} v${versionBump.newVersion}`, releaseNotes, {
+    prerelease: !!options.prerelease
+  });
 }
 async function performGitOperations(config, options, pkg, newVersion, tag, changelogPath) {
   if (config.git.commitChanges && !options.noCommit) {
+    if (config.git.beforeCommit) {
+      const hookSuccess = await runBeforeCommitHook(config.git.beforeCommit);
+      if (!hookSuccess) {
+        console.warn("⚠️  beforeCommit hook failed, proceeding with unformatted files");
+      }
+    }
     const commitMessage = config.git.commitMessage.replace("{{package}}", pkg.name).replace("{{version}}", newVersion);
     await createCommit(commitMessage, [resolve2(pkg.path, "package.json"), changelogPath]);
   }
@@ -1317,15 +1471,27 @@ async function release(packageName, options = {}) {
       date: new Date,
       repoUrl: repoInfo.url,
       version: versionBump.newVersion
-    }, config.changelog);
+    }, config.changelog, pkg.name);
     if (options.dryRun) {
       printDryRunInfo(pkg, currentVersion, versionBump, tag, commits, changelogEntry);
       result.success = true;
       return result;
     }
+    const retryFn = createRetryFunction(config.retry);
     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);
+    try {
+      result.releaseUrl = await createGitVerseRelease(options, repoInfo, commits, config, pkg, versionBump, tag, retryFn);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (config.gitverse.failOnError) {
+        throw new Error(`GitVerse release creation failed: ${errorMessage}`);
+      }
+      result.warnings.push(`Failed to create GitVerse release: ${errorMessage}`);
+      console.warn(`
+⚠️  Warning: ${errorMessage}
+`);
+    }
     result.success = true;
     printSuccessInfo(pkg, currentVersion, versionBump.newVersion, tag, result.releaseUrl);
     return result;
@@ -1360,14 +1526,187 @@ async function resolvePackage(config, packageName) {
   }
   return pkg;
 }
+async function createReleaseOnly(tag, packageName, configPath) {
+  const result = {
+    errors: [],
+    newVersion: "",
+    oldVersion: "",
+    packageName: packageName || "unknown",
+    success: false,
+    tag,
+    warnings: []
+  };
+  try {
+    const config = await loadConfig(configPath);
+    validateConfig(config);
+    const repoInfo = await getRepoInfo();
+    const pkg = await resolvePackage(config, packageName);
+    result.packageName = pkg.packageName;
+    const version = tag.replace(pkg.tagPrefix, "");
+    result.newVersion = version;
+    const rawCommits = await getCommitsSinceTag(pkg.tagPrefix, pkg.path);
+    const commits = parseCommits(rawCommits);
+    const retryFn = createRetryFunction(config.retry);
+    const gitverseClient = createGitVerseClient(repoInfo, retryFn);
+    if (config.gitverse.checkExisting) {
+      const exists = await gitverseClient.releaseExists(tag);
+      if (exists) {
+        console.log(`
+✅ Release ${tag} already exists
+`);
+        result.releaseUrl = `${repoInfo.url}/releases/tag/${tag}`;
+        result.success = true;
+        return result;
+      }
+    }
+    const releaseNotes = generateReleaseNotes(commits, config.changelog, repoInfo.url, pkg.name);
+    result.releaseUrl = await gitverseClient.createRelease(tag, `${pkg.packageName} v${version}`, releaseNotes);
+    result.success = true;
+    console.log(`
+✅ Release created successfully!`);
+    console.log(`\uD83D\uDCE6 Package: ${pkg.packageName}`);
+    console.log(`\uD83C\uDFF7️  Tag: ${tag}`);
+    console.log(`\uD83C\uDF10 Release: ${result.releaseUrl}
+`);
+    return result;
+  } catch (error) {
+    result.success = false;
+    result.errors.push(error instanceof Error ? error.message : String(error));
+    console.error(`
+❌ Release creation failed:
+`);
+    console.error(error);
+    console.error("");
+    return result;
+  }
+}
 
 // src/cli.ts
 import { parseArgs } from "node:util";
+
+// src/utils/commitlint-generator.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+async function generateCommitlint(config, options = {}) {
+  const {
+    output = "commitlint.config.ts",
+    format = "ts",
+    scopes,
+    scopeRequired = false,
+    headerMaxLength = 100,
+    comments = true,
+    dryRun = false,
+    verbose = false
+  } = options;
+  const commitTypes = extractCommitTypes(config);
+  const commitScopes = extractCommitScopes(config, scopes);
+  const configContent = generateConfigContent(commitTypes, commitScopes, { headerMaxLength, scopeRequired }, format, comments);
+  if (verbose) {
+    console.log(`
+\uD83D\uDCCA Configuration:`);
+    console.log(`  Types: ${commitTypes.join(", ")}`);
+    console.log(`  Scopes: ${commitScopes.join(", ")}`);
+    console.log(`  Scope required: ${scopeRequired}`);
+    console.log(`  Header max length: ${headerMaxLength}`);
+  }
+  if (dryRun) {
+    console.log(`
+\uD83D\uDD0D Dry-run mode - Preview of generated config:
+`);
+    console.log(configContent);
+    console.log(`
+\uD83D\uDCDD Would write to: ${output}`);
+    return;
+  }
+  await writeFile2(output, configContent);
+  console.log(`✅ Generated commitlint config: ${output}`);
+}
+function extractCommitTypes(config) {
+  return Object.keys(config.changelog.types);
+}
+function extractCommitScopes(config, additionalScopes) {
+  const scopes = [];
+  if (config.monorepo?.enabled && config.monorepo.packages) {
+    scopes.push(...config.monorepo.packages.map((p) => p.name));
+  }
+  const defaultScopes = ["deps", "ci", "docs"];
+  scopes.push(...defaultScopes);
+  if (additionalScopes) {
+    scopes.push(...additionalScopes);
+  }
+  return [...new Set(scopes)].sort();
+}
+function generateConfigContent(types2, scopes, rules, format, comments) {
+  if (format === "json") {
+    return generateJSONConfig(types2, scopes, rules);
+  }
+  const isTS = format === "ts";
+  const _ext = isTS ? "ts" : "js";
+  const header = comments ? `// AUTO-GENERATED by gitverse-release
+// Run: gitverse-release generate-commitlint
+// DO NOT EDIT MANUALLY - Changes will be overwritten
+
+` : "";
+  const typeImport = isTS ? `import type { UserConfig } from "@commitlint/types";
+
+` : "";
+  const configDeclaration = isTS ? "const config: UserConfig = " : "const config = ";
+  const typesComment = comments ? `    // Types from release config
+` : "";
+  const scopesComment = comments ? `    // Scopes from release config
+` : "";
+  const scopeEmptyRule = rules.scopeRequired ? `    "scope-empty": [2, "never"], // scope required
+` : `    "scope-empty": [0], // scope optional
+`;
+  const content = `${header}${typeImport}${configDeclaration}{
+  extends: ["@commitlint/config-conventional"],
+
+  rules: {
+${typesComment}    "type-enum": [2, "always", ${JSON.stringify(types2)}],
+
+${scopesComment}    "scope-enum": [2, "always", ${JSON.stringify(scopes)}],
+${scopeEmptyRule}
+    "subject-case": [2, "always", "lower-case"],
+    "subject-empty": [2, "never"],
+    "header-max-length": [2, "always", ${rules.headerMaxLength}],
+    "body-leading-blank": [2, "always"],
+    "footer-leading-blank": [2, "always"],
+  },
+};
+
+${isTS ? "export default config;" : "module.exports = config;"}
+`;
+  return content;
+}
+function generateJSONConfig(types2, scopes, rules) {
+  const config = {
+    extends: ["@commitlint/config-conventional"],
+    rules: {
+      "body-leading-blank": [2, "always"],
+      "footer-leading-blank": [2, "always"],
+      "header-max-length": [2, "always", rules.headerMaxLength],
+      "scope-empty": rules.scopeRequired ? [2, "never"] : [0],
+      "scope-enum": [2, "always", scopes],
+      "subject-case": [2, "always", "lower-case"],
+      "subject-empty": [2, "never"],
+      "type-enum": [2, "always", types2]
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+
+// src/cli.ts
 var HELP_TEXT = `
 gitverse-release - Release automation tool for GitVerse
 
 Usage:
   gitverse-release [package-name] [options]
+  gitverse-release create-only --tag <tag> [options]
+  gitverse-release generate-commitlint [options]
+
+Commands:
+  (default)              Full release: update version, commit, tag, push, create release
+  create-only            Create only GitVerse Release for existing tag (recovery mode)
+  generate-commitlint    Generate commitlint config from release config
 
 Options:
   --dry-run              Test run without making changes
@@ -1379,9 +1718,18 @@ Options:
   --no-tag               Skip creating git tag
   --no-push              Skip pushing to remote
   --no-release           Skip creating GitVerse Release
+  --tag <tag>            Tag name (for create-only command)
   --verbose              Verbose output
   --help                 Show this help message
 
+Generate Commitlint Options:
+  --output <path>        Output path for commitlint config (default: commitlint.config.ts)
+  --format <format>      Output format: ts, js, json (default: ts)
+  --scopes <scopes>      Additional scopes (comma-separated)
+  --scope-required       Make scope required in commits
+  --header-max-length <n> Maximum header length (default: 100)
+  --no-comments          Disable comments in generated config
+
 Examples:
   # Auto-detect version and create release
   gitverse-release sdk
@@ -1398,6 +1746,16 @@ Examples:
   # Custom config
   gitverse-release sdk --config ./my-config.json
 
+  # Create only release for existing tag (recovery)
+  gitverse-release create-only --tag v1.2.3
+  gitverse-release create-only --tag sdk-v4.0.2 --package sdk
+
+  # Generate commitlint config
+  gitverse-release generate-commitlint
+  gitverse-release generate-commitlint --dry-run
+  gitverse-release generate-commitlint --format js --output .commitlintrc.js
+  gitverse-release generate-commitlint --scopes deps,ci,docs --scope-required
+
 Environment Variables:
   GITVERSE_TOKEN         GitVerse API token (required)
 
@@ -1411,13 +1769,20 @@ async function main() {
       options: {
         config: { type: "string" },
         "dry-run": { type: "boolean" },
+        format: { type: "string" },
+        "header-max-length": { type: "string" },
         help: { type: "boolean" },
+        "no-comments": { type: "boolean" },
         "no-commit": { type: "boolean" },
         "no-push": { type: "boolean" },
         "no-release": { type: "boolean" },
         "no-tag": { type: "boolean" },
+        output: { type: "string" },
         package: { type: "string" },
         prerelease: { type: "string" },
+        "scope-required": { type: "boolean" },
+        scopes: { type: "string" },
+        tag: { type: "string" },
         verbose: { type: "boolean" },
         version: { type: "string" }
       }
@@ -1426,6 +1791,49 @@ async function main() {
       console.log(HELP_TEXT);
       process.exit(0);
     }
+    const command = positionals[0];
+    if (command === "generate-commitlint") {
+      const config = await loadConfig(values.config);
+      const scopesList = values.scopes ? values.scopes.split(",").map((s) => s.trim()) : config.commitlint.scopes;
+      const headerMaxLength = values["header-max-length"] ? Number.parseInt(values["header-max-length"], 10) : config.commitlint.headerMaxLength;
+      await generateCommitlint(config, {
+        comments: values["no-comments"] !== undefined ? !values["no-comments"] : config.commitlint.comments,
+        dryRun: values["dry-run"],
+        format: values.format ?? config.commitlint.format,
+        headerMaxLength,
+        output: values.output ?? config.commitlint.output,
+        scopeRequired: values["scope-required"] ?? config.commitlint.scopeRequired,
+        scopes: scopesList,
+        verbose: values.verbose
+      });
+      process.exit(0);
+    }
+    if (command === "create-only") {
+      if (!values.tag) {
+        console.error("❌ Error: --tag is required for create-only command");
+        console.log(`
+Usage: gitverse-release create-only --tag <tag> [--package <name>]`);
+        process.exit(1);
+      }
+      const result2 = await createReleaseOnly(values.tag, values.package, values.config);
+      if (values.verbose) {
+        console.log(`
+\uD83D\uDCCA Result:`);
+        console.log(JSON.stringify(result2, null, 2));
+      }
+      if (result2.errors.length > 0) {
+        console.error(`
+❌ Errors:`);
+        for (const error of result2.errors) {
+          console.error(`  - ${error}`);
+        }
+        process.exit(1);
+      }
+      if (!result2.success) {
+        process.exit(1);
+      }
+      process.exit(0);
+    }
     const options = {
       config: values.config,
       dryRun: values["dry-run"],
@@ -1438,7 +1846,7 @@ async function main() {
       verbose: values.verbose,
       version: values.version
     };
-    const packageName = positionals[0] || options.package;
+    const packageName = command || options.package;
     const result = await release(packageName, options);
     if (options.verbose) {
       console.log(`
@@ -1473,4 +1881,4 @@ async function main() {
 }
 main();
 
-//# debugId=C891F93BC32B0BA664756E2164756E21
+//# debugId=CBF028718EBEA1DE64756E2164756E21