@vc-shell/release-config 1.2.4-beta.6 → 1.2.4-beta.8

package/README.md

@@ -13,6 +13,7 @@ Release management system powered by Lerna for VC-Shell monorepo.
 - **Root package versioning** - root package.json stays synchronized
 - **Apps synchronization** - automatic @vc-shell/* dependency updates in apps/
 - **Initial changelog generation** - create changelogs from entire git history
+- **Lockstep mode** - optional `forcePublish: true` bumps every package on each release
 - **Backward compatible** - maintains existing release script API
 
 ## Usage
@@ -24,6 +25,7 @@ import { release } from "@vc-shell/release-config";
 
 release({
   packages: [".", "framework", "cli/*", "configs/*"],
+  forcePublish: true,
   toTag: (version) => `v${version}`,
   bumpVersion: async (pkgName, version) => {
     // Optional: custom version bump logic (Lerna handles this automatically)
@@ -44,7 +46,7 @@ release({
 **Version bump:**
 4. Lerna analyzes git history using conventional commits
 5. Determines which packages changed
-6. Updates all package versions (fixed versioning)
+6. Updates all package versions (or all packages when `forcePublish: true`)
 7. Generates CHANGELOG.md for each package
 8. Synchronizes internal dependencies automatically
 9. Creates git commit and tag

package/dist/cli-generate-changelogs.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as i } from "./generate-changelogs-ujWf_gXz.js";
+import { h as i } from "./generate-changelogs-Dx-dDlOU.js";
 import { resolve as s } from "node:path";
 import e from "chalk";
 async function l() {

package/dist/generate-changelogs-Dx-dDlOU.js

@@ -0,0 +1,538 @@
+import { sync as d } from "cross-spawn";
+import { existsSync as N, readFileSync as E, writeFileSync as b } from "node:fs";
+import C from "node:path";
+import l from "chalk";
+import { valid as v, rcompare as H } from "semver";
+function st(t, e) {
+  const o = d(
+    "git",
+    [
+      "describe",
+      "--tags",
+      "--abbrev=0",
+      "--first-parent",
+      "--match",
+      `${e}${t}.*`
+    ],
+    {
+      stdio: "pipe",
+      encoding: "utf-8"
+    }
+  );
+  return o.status === 0 && o.stdout ? o.stdout.toString().trim() : null;
+}
+function O() {
+  const t = d("git", ["remote", "get-url", "origin"], {
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  return t.status === 0 && t.stdout ? t.stdout.toString().trim().replace(/\.git$/, "").replace(/^git@github\.com:/, "https://github.com/") : null;
+}
+function V(t, e, o) {
+  const r = ["log", "--format=%H %s", `${t}..${e}`];
+  o && r.push("--", o);
+  const i = d("git", r, {
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  if (i.status !== 0 || !i.stdout) return [];
+  const n = [], s = i.stdout.toString().trim().split(`
+`).filter(Boolean), c = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)$/;
+  for (const a of s) {
+    const g = a.indexOf(" ");
+    if (g === -1) continue;
+    const u = a.substring(0, g), p = a.substring(g + 1).match(c);
+    p && n.push({
+      hash: u,
+      shortHash: u.substring(0, 7),
+      type: p[1],
+      scope: p[2] || null,
+      subject: p[4],
+      breaking: !!p[3]
+    });
+  }
+  return n;
+}
+function it() {
+  const t = d("git", ["describe", "--tags", "--abbrev=0"], {
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  return t.status === 0 && t.stdout ? t.stdout.toString().trim() : null;
+}
+function rt() {
+  d("git", ["add", "-u"], { stdio: "inherit" }).status !== 0 && (console.error(l.red(`
+Failed to stage changes
+`)), process.exit(1)), d("git", ["commit", "--amend", "--no-edit"], { stdio: "inherit" }).status !== 0 && (console.error(l.red(`
+Failed to amend commit
+`)), process.exit(1));
+}
+function ct(t) {
+  d("git", ["tag", "-f", "-a", t, "-m", t], { stdio: "inherit" }).status !== 0 && (console.error(l.red(`
+Failed to recreate tag
+`)), process.exit(1));
+}
+function at(t) {
+  console.log(l.cyan(`
+Pushing changes to remote...
+`)), d("git", ["push", "origin", "HEAD", "--force-with-lease"], { stdio: "inherit" }).status !== 0 && (console.error(l.red(`
+Failed to push commit
+`)), process.exit(1)), d("git", ["push", "origin", t, "--force"], { stdio: "inherit" }).status !== 0 && (console.error(l.red(`
+Failed to push tag
+`)), process.exit(1));
+}
+function x(t) {
+  const e = d("git", ["tag", "-l", `${t}*`], {
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  return e.status !== 0 || !e.stdout ? [] : e.stdout.toString().trim().split(`
+`).filter(Boolean).sort((r, i) => {
+    const n = v(r.startsWith(t) ? r.slice(t.length) : r), s = v(i.startsWith(t) ? i.slice(t.length) : i);
+    return n && s ? H(n, s) : i.localeCompare(r);
+  });
+}
+function w(t, e) {
+  const o = x(e), r = `${e}${t}`, i = o.indexOf(r);
+  if (i !== -1)
+    return i >= o.length - 1 ? null : o[i + 1];
+  const n = v(t);
+  if (!n)
+    return console.warn(l.yellow(`  getPreviousVersionTag: invalid version "${t}"`)), null;
+  for (const s of o) {
+    const c = v(s.startsWith(e) ? s.slice(e.length) : s);
+    if (c && H(n, c) < 0)
+      return s;
+  }
+  return null;
+}
+function ut() {
+  const t = d("git", ["log", "-1", "--format=%s"], {
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  return t.status === 0 && t.stdout ? t.stdout.toString().trim() : null;
+}
+const S = /^#{1,2}\s+(?:\[)?(\d[\da-z.-]*)(?:\])?/i, j = /\*\*Note:\*\*\s+Version bump only[^\n]*/gi;
+function T(t) {
+  let e = t;
+  return e = e.replace(/^# CHANGELOG\s*\n/gm, ""), e = e.replace(/^# Change Log\s*\n/gm, ""), e = e.replace(
+    /^All notable changes to this (project|package) will be documented in this file\.\s*\n/gm,
+    ""
+  ), e = e.replace(
+    /^See \[Conventional Commits\]\(https:\/\/conventionalcommits\.org\) for commit guidelines\.\s*\n/gm,
+    ""
+  ), e = e.replace(/\n{3,}/g, `
+
+`), e;
+}
+function L(t) {
+  return t.replace(
+    /^(#{1,2}\s+(?:\[[^\]]+\]|\d[\da-z.-]*)[^\n]*\n)\n(?=#{1,2}\s+(?:\[|\d)|$)/gim,
+    `$1
+**Note:** Version bump only for package
+
+`
+  );
+}
+function lt(t, e = !1) {
+  console.log(l.cyan(`
+Enhancing changelogs...
+`));
+  for (const o of t) {
+    const r = C.join(o.path, "CHANGELOG.md");
+    if (!N(r)) continue;
+    let i = E(r, "utf-8");
+    i = T(i), i = L(i), i = I(i), i = i.trim() + `
+`, e || b(r, i, "utf-8");
+  }
+}
+function gt(t, e, o = !1) {
+  console.log(l.cyan(`
+Ensuring current version entries for ${e}...
+`));
+  let r = 0;
+  for (const i of t) {
+    const n = C.join(i.path, "CHANGELOG.md");
+    if (!N(n)) continue;
+    let s = E(n, "utf-8");
+    const c = e.replace(/\./g, "\\.");
+    if (new RegExp(`^#{1,2}\\s+\\[?${c}\\]?\\b`, "m").test(s)) continue;
+    const g = `## ${e}
+
+**Note:** Version bump only for package
+
+`, u = s.match(/^#{1,2}\s+\[?\d[\da-z.-]*\]?[^\n]*/m);
+    u && u.index !== void 0 ? s = s.substring(0, u.index) + g + s.substring(u.index) : s.trim() ? s = s.trimEnd() + `
+
+` + g : s = g, r++, o || b(n, s, "utf-8");
+  }
+  r > 0 ? console.log(l.green(`  Inserted ${r} current version entr${r === 1 ? "y" : "ies"}`)) : console.log(l.gray("  All packages already have a current version entry"));
+}
+function ft(t, e, o = "v", r = !1) {
+  console.log(l.cyan(`
+Supplementing current version entries for ${e}...
+`));
+  const i = w(e, o);
+  if (!i) {
+    console.log(l.gray("  No previous release tag found; skipping current version supplementation"));
+    return;
+  }
+  const n = O();
+  let s = 0;
+  for (const c of t) {
+    const a = C.join(c.path, "CHANGELOG.md");
+    if (!N(a)) continue;
+    const g = V(i, "HEAD", c.path), u = W(g, n);
+    if (!u) continue;
+    const f = E(a, "utf-8"), p = B(f, e, u);
+    p !== f && (s++, r || b(a, p, "utf-8"));
+  }
+  s > 0 ? console.log(l.green(`  Supplemented ${s} current version entr${s === 1 ? "y" : "ies"}`)) : console.log(l.gray("  No current version entries needed supplementation"));
+}
+function y(t) {
+  return t.replace(j, "").trim().length === 0;
+}
+function k(t, e, o) {
+  if (!e || o.length === 0) return;
+  const r = o.join(`
+`).trim();
+  if (!r) return;
+  const i = t[e];
+  (!i || y(i) && !y(r)) && (t[e] = r);
+}
+function I(t) {
+  const e = t.split(`
+`), o = [], r = [], i = /* @__PURE__ */ new Map();
+  let n = null;
+  const s = () => {
+    if (!n) return;
+    const c = n.lines.slice(1).join(`
+`).trim(), a = i.get(n.version);
+    if (a === void 0) {
+      i.set(n.version, r.length), r.push(n), n = null;
+      return;
+    }
+    const u = r[a].lines.slice(1).join(`
+`).trim();
+    y(u) && !y(c) && (r[a] = n), n = null;
+  };
+  for (const c of e) {
+    const a = c.match(S);
+    if (a) {
+      s(), n = { version: a[1], lines: [c] };
+      continue;
+    }
+    n ? n.lines.push(c) : o.push(c);
+  }
+  return s(), [...o, ...r.flatMap((c) => c.lines)].join(`
+`);
+}
+function B(t, e, o) {
+  const r = e.replace(/\./g, "\\."), i = new RegExp(
+    `(^#{1,2}\\s+\\[?${r}\\]?[^\\n]*\\n)([\\s\\S]*?)(?=^#{1,2}\\s+\\[?\\d[\\da-z.-]*\\]?|$)`,
+    "m"
+  );
+  return t.replace(i, (n, s, c) => y(c) ? `${s}
+${o.trim()}
+
+` : n);
+}
+function P(t) {
+  const e = {}, o = {}, r = t.split(`
+`);
+  let i = null, n = [];
+  for (const s of r) {
+    const c = s.match(S);
+    c ? (k(e, i, n), i = c[1], n = [], o[i] || (o[i] = s.replace(/^#{1,2}\s+/, ""))) : i && s.trim() !== "" && !s.startsWith("# CHANGELOG") && !s.startsWith("# Change Log") && !s.startsWith("All notable changes") && !s.startsWith("See [Conventional Commits]") && n.push(s);
+  }
+  return k(e, i, n), { versionContent: e, versionHeaders: o };
+}
+function F(t, e) {
+  return [...t].sort((o, r) => {
+    const i = R(e?.[o]), n = R(e?.[r]);
+    return i !== null && n !== null && i !== n ? n - i : v(o) && v(r) ? H(o, r) : r.localeCompare(o);
+  });
+}
+function R(t) {
+  if (!t) return null;
+  const e = t.match(/\((\d{4}-\d{2}-\d{2})\)\s*$/);
+  if (!e) return null;
+  const o = Date.parse(`${e[1]}T00:00:00Z`);
+  return Number.isNaN(o) ? null : o;
+}
+function D(t, e = !1) {
+  const { packages: o, rootDir: r = process.cwd(), includeRootHeader: i = !1 } = t;
+  console.log(l.cyan(`
+Generating root CHANGELOG with package grouping...
+`));
+  const n = C.join(r, "CHANGELOG.md"), s = {}, c = {};
+  for (const u of o) {
+    const f = C.join(r, u.path, "CHANGELOG.md");
+    if (!N(f)) continue;
+    const p = E(f, "utf-8"), m = P(p);
+    for (const [h, $] of Object.entries(m.versionContent))
+      s[h] || (s[h] = {}), s[h][u.displayName] = $, !c[h] && m.versionHeaders[h] && (c[h] = m.versionHeaders[h]);
+  }
+  let a = "";
+  i && (a = `# CHANGELOG
+
+All notable changes to this monorepo will be documented in this file.
+
+`);
+  const g = F(Object.keys(s), c);
+  for (const u of g) {
+    const f = s[u], p = Object.values(f).some(
+      ($) => !!$?.trim() && !y($)
+    ), m = c[u] || u;
+    if (a += `## ${m}
+
+`, !p) {
+      a += `**Note:** Version bump only for package
+
+`;
+      continue;
+    }
+    let h = !1;
+    for (const $ of o) {
+      const G = f[$.displayName];
+      G && G.trim() && (y(G) || (h = !0, a += `### ${$.displayName}
+
+`, a += `${G}
+
+`));
+    }
+    h || (a += `**Note:** Version bump only for package
+
+`);
+  }
+  a = a.replace(/\n{3,}/g, `
+
+`), a = a.trim() + `
+`, e ? console.log(l.yellow(`  [dry-run] Would write root CHANGELOG.md (${g.length} versions)`)) : (b(n, a, "utf-8"), console.log(l.green("  Generated root CHANGELOG.md with package grouping")));
+}
+const M = {
+  feat: "Features",
+  fix: "Bug Fixes",
+  perf: "Performance Improvements",
+  revert: "Reverts",
+  docs: "Documentation",
+  style: "Styles",
+  refactor: "Code Refactoring",
+  test: "Tests",
+  build: "Build System",
+  ci: "Continuous Integration"
+};
+function W(t, e) {
+  const o = {};
+  for (const n of t) {
+    const s = M[n.type];
+    s && (o[s] || (o[s] = []), o[s].push(n));
+  }
+  if (Object.keys(o).length === 0) return "";
+  let r = "";
+  const i = [
+    "Features",
+    "Bug Fixes",
+    "Performance Improvements",
+    "Reverts",
+    "Documentation",
+    "Styles",
+    "Code Refactoring",
+    "Tests",
+    "Build System",
+    "Continuous Integration"
+  ];
+  for (const n of i) {
+    const s = o[n];
+    if (!(!s || s.length === 0)) {
+      r += `### ${n}
+
+`;
+      for (const c of s) {
+        const a = e ? `([${c.shortHash}](${e}/commit/${c.hash}))` : `(${c.shortHash})`;
+        r += c.scope ? `- **${c.scope}:** ${c.subject} ${a}
+` : `- ${c.subject} ${a}
+`;
+      }
+      r += `
+`;
+    }
+  }
+  return r.trim();
+}
+const A = [
+  { heading: "Features", types: ["feat"] },
+  { heading: "Bug Fixes", types: ["fix"] },
+  { heading: "Performance Improvements", types: ["perf"] },
+  { heading: "Reverts", types: ["revert"] },
+  { heading: "Documentation", types: ["docs"] },
+  { heading: "Styles", types: ["style"] },
+  { heading: "Code Refactoring", types: ["refactor"] },
+  { heading: "Tests", types: ["test"] },
+  { heading: "Build System", types: ["build"] },
+  { heading: "CI/CD", types: ["ci"] },
+  { heading: "Chores", hidden: !0, types: ["chore"] }
+], _ = new Map(
+  A.flatMap(
+    (t) => t.types.map((e) => [e, { heading: t.heading, hidden: t.hidden }])
+  )
+);
+function z(t, e, o, r) {
+  const i = ["log", "--format=%H %s", e ? `${e}..${t}` : t];
+  r && i.push("--", r);
+  const n = d("git", i, {
+    stdio: "pipe",
+    encoding: "utf-8",
+    cwd: o
+  });
+  if (n.status !== 0 || !n.stdout) return [];
+  const s = [], c = n.stdout.toString().trim().split(`
+`).filter(Boolean), a = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)$/;
+  for (const g of c) {
+    const u = g.indexOf(" ");
+    if (u === -1) continue;
+    const f = g.substring(0, u), m = g.substring(u + 1).match(a);
+    m && s.push({
+      hash: f,
+      shortHash: f.substring(0, 7),
+      type: m[1],
+      scope: m[2] || null,
+      subject: m[4],
+      breaking: !!m[3]
+    });
+  }
+  return s;
+}
+function Y(t, e) {
+  const o = d("git", ["tag", "-l", `${e}*`], {
+    stdio: "pipe",
+    encoding: "utf-8",
+    cwd: t
+  });
+  if (o.status !== 0 || !o.stdout) return [];
+  const r = o.stdout.toString().trim().split(`
+`).filter(Boolean), i = /* @__PURE__ */ new Map();
+  for (const n of r)
+    i.set(n, U(t, n));
+  return r.sort((n, s) => {
+    const c = i.get(n) || 0, a = i.get(s) || 0;
+    return c !== a ? a - c : s.localeCompare(n);
+  });
+}
+function K(t) {
+  const e = d("git", ["remote", "get-url", "origin"], {
+    stdio: "pipe",
+    encoding: "utf-8",
+    cwd: t
+  });
+  return e.status !== 0 || !e.stdout ? null : e.stdout.toString().trim().replace(/\.git$/, "").replace(/^git@github\.com:/, "https://github.com/");
+}
+function U(t, e) {
+  const o = d("git", ["log", "-1", "--format=%ct", e], {
+    stdio: "pipe",
+    encoding: "utf-8",
+    cwd: t
+  });
+  return o.status === 0 && o.stdout?.trim() && Number(o.stdout.trim()) || 0;
+}
+function Z(t, e) {
+  const o = d("git", ["log", "-1", "--format=%cs", e], {
+    stdio: "pipe",
+    encoding: "utf-8",
+    cwd: t
+  });
+  return o.status === 0 && o.stdout?.trim() ? o.stdout.trim() : "";
+}
+function q(t, e, o, r, i) {
+  const n = Z(t, o);
+  return i && r ? `## [${e}](${i}/compare/${r}...${o})${n ? ` (${n})` : ""}` : `## ${e}${n ? ` (${n})` : ""}`;
+}
+function J(t, e) {
+  const o = /* @__PURE__ */ new Map(), r = [];
+  for (const n of t) {
+    const s = _.get(n.type);
+    !s || s.hidden || (o.has(s.heading) || o.set(s.heading, []), o.get(s.heading).push(n), n.breaking && r.push(n));
+  }
+  if (o.size === 0)
+    return "";
+  const i = [];
+  for (const n of A) {
+    if (n.hidden) continue;
+    const s = o.get(n.heading);
+    if (!(!s || s.length === 0)) {
+      i.push(`### ${n.heading}`, "");
+      for (const c of s) {
+        const a = e ? `([${c.shortHash}](${e}/commit/${c.hash}))` : `(${c.shortHash})`;
+        i.push(
+          c.scope ? `- **${c.scope}:** ${c.subject} ${a}` : `- ${c.subject} ${a}`
+        );
+      }
+      i.push("");
+    }
+  }
+  if (r.length > 0) {
+    i.push("### BREAKING CHANGES", "");
+    for (const n of r)
+      i.push(n.scope ? `- **${n.scope}:** ${n.subject}` : `- ${n.subject}`);
+    i.push("");
+  }
+  return i.join(`
+`).trim();
+}
+function Q(t, e, o, r) {
+  const i = Y(t, o), n = [];
+  for (let s = 0; s < i.length; s++) {
+    const c = i[s], a = s < i.length - 1 ? i[s + 1] : null, g = c.startsWith(o) ? c.slice(o.length) : c, u = q(t, g, c, a, r), f = z(
+      c,
+      a,
+      t,
+      C.join(t, e.path)
+    ), p = J(f, r);
+    n.push(u), n.push(""), n.push(p || "**Note:** Version bump only for package"), n.push("");
+  }
+  return n.join(`
+`).trim() + `
+`;
+}
+async function dt(t) {
+  const {
+    packages: e,
+    rootDir: o = process.cwd(),
+    generateRoot: r = !0,
+    includeRootHeader: i = !0,
+    tagVersionPrefix: n = "v"
+  } = t;
+  console.log(l.cyan(`
+Generating initial CHANGELOG.md files...
+`));
+  const s = K(o);
+  for (const c of e) {
+    const a = C.join(o, c.path, "CHANGELOG.md");
+    if (N(a)) {
+      const u = `${a}.backup`, f = E(a, "utf-8");
+      b(u, f, "utf-8"), console.log(l.gray(`  Backed up ${a} to ${u}`));
+    }
+    console.log(l.blue(`
+Generating changelog for ${c.name}...`));
+    const g = Q(o, c, n, s);
+    b(a, g, "utf-8"), console.log(l.green(`  Generated ${a}`));
+  }
+  r && await D({ packages: e, rootDir: o, includeRootHeader: i }), console.log(l.green(`
+Initial changelogs generated successfully!`)), console.log(l.cyan(`
+Next steps:`)), console.log(l.cyan("  1. Review the generated CHANGELOG.md files")), console.log(l.cyan("  2. Make any manual adjustments if needed")), console.log(l.cyan(`  3. Commit the changes
+`));
+}
+export {
+  gt as a,
+  it as b,
+  ut as c,
+  rt as d,
+  lt as e,
+  st as f,
+  D as g,
+  dt as h,
+  at as p,
+  ct as r,
+  ft as s
+};