package-versioner 0.0.1

package/dist/index.js

@@ -0,0 +1,648 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { exit as exit2 } from "process";
+import chalk2 from "chalk";
+import { Command } from "commander";
+import figlet from "figlet";
+
+// package.json
+var package_default = {
+  name: "package-versioner",
+  description: "A powerful CLI tool for automated semantic versioning based on Git history and conventional commits. Supports monorepos with synchronized or independent package versioning strategies.",
+  version: "0.0.1",
+  type: "module",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  author: {
+    name: "Sam Maister",
+    email: "goosewobbler@protonmail.com"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/goosewobbler/package-versioner",
+    homepage: "https://github.com/goosewobbler/package-versioner"
+  },
+  keywords: ["version", "semver", "git", "package"],
+  license: "MIT",
+  files: ["dist/**", "package-versioner.schema.json"],
+  bin: {
+    "package-versioner": "./dist/index.js"
+  },
+  scripts: {
+    build: "tsup src/index.ts --format esm,cjs --dts",
+    dev: "tsup src/index.ts --format esm,cjs --watch --dts",
+    clean: "rm -rf node_modules && rm -rf dist",
+    test: "vitest run --coverage",
+    "test:watch": "vitest --coverage",
+    lint: "biome check .",
+    "lint:fix": "biome check --apply .",
+    format: "biome format --write .",
+    "format:check": "biome format .",
+    fix: "pnpm run lint:fix && pnpm run format",
+    prepare: "husky"
+  },
+  "lint-staged": {
+    "*.{js,ts,jsx,tsx}": ["biome check --apply", "biome format --write"]
+  },
+  devDependencies: {
+    "@biomejs/biome": "^1.9.4",
+    "@types/figlet": "^1.5.5",
+    "@types/node": "^18.14.0",
+    "@types/semver": "^7.3.13",
+    "@vitest/coverage-v8": "^3.1.1",
+    husky: "^9.1.7",
+    "lint-staged": "^15.5.0",
+    tsup: "^5.10.1",
+    typescript: "^5.8.3",
+    vitest: "^3.1.1"
+  },
+  dependencies: {
+    "@manypkg/get-packages": "^2.2.2",
+    chalk: "^5.4.1",
+    commander: "^13.1.0",
+    "conventional-changelog-angular": "^8.0.0",
+    "conventional-recommended-bump": "^11.0.0",
+    figlet: "^1.8.0",
+    "git-semver-tags": "^8.0.0",
+    semver: "^7.7.1"
+  },
+  packageManager: "pnpm@10.8.0+sha512.0e82714d1b5b43c74610193cb20734897c1d00de89d0e18420aebc5977fa13d780a9cb05734624e81ebd81cc876cd464794850641c48b9544326b5622ca29971"
+};
+
+// src/config.ts
+import * as fs from "fs";
+import { cwd } from "process";
+function loadConfig(configPath) {
+  const localProcess = cwd();
+  const filePath = configPath || `${localProcess}/version.config.json`;
+  return new Promise((resolve, reject) => {
+    fs.readFile(filePath, "utf-8", (err, data) => {
+      if (err) {
+        reject(new Error(`Could not locate the config file at ${filePath}: ${err.message}`));
+        return;
+      }
+      try {
+        const config = JSON.parse(data);
+        resolve(config);
+      } catch (err2) {
+        const errorMessage = err2 instanceof Error ? err2.message : String(err2);
+        reject(new Error(`Failed to parse config file ${filePath}: ${errorMessage}`));
+      }
+    });
+  });
+}
+
+// src/utils.ts
+import fs2 from "fs";
+import chalk from "chalk";
+import { getSemverTags } from "git-semver-tags";
+
+// src/git.ts
+import { exec, execSync as syncExec } from "child_process";
+import { existsSync, statSync } from "fs";
+import { join } from "path";
+import { cwd as cwd2 } from "process";
+var execAsync = (command) => {
+  return new Promise((resolve, reject) => {
+    const options = { maxBuffer: 1024 * 1024 * 10 };
+    exec(
+      command,
+      options,
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve({ stdout: stdout.toString(), stderr: stderr.toString() });
+        }
+      }
+    );
+  });
+};
+var execSync = (command, args) => syncExec(command, { maxBuffer: 1024 * 1024 * 10, ...args });
+async function gitAdd(files) {
+  const command = `git add ${files.join(" ")}`;
+  return execAsync(command);
+}
+async function gitCommit(options) {
+  const command = ["commit"];
+  if (options.amend) {
+    command.push("--amend");
+  }
+  if (options.author) {
+    command.push(`--author="${options.author}"`);
+  }
+  if (options.date) {
+    command.push(`--date="${options.date}"`);
+  }
+  if (options.skipHooks) {
+    command.push("--no-verify");
+  }
+  command.push(`-m "${options.message}"`);
+  return execAsync(`git ${command.join(" ")}`);
+}
+async function createGitTag(options) {
+  const { tag, message = "", args = "" } = options;
+  const command = `git tag -a -m "${message}" ${tag} ${args}`;
+  return execAsync(command);
+}
+function getCommitsLength(pkgRoot) {
+  try {
+    const gitCommand = `git rev-list --count HEAD ^$(git describe --tags --abbrev=0) ${pkgRoot}`;
+    const amount = execSync(gitCommand).toString().trim();
+    return Number(amount);
+  } catch {
+    return 0;
+  }
+}
+function isGitRepository(directory) {
+  const gitDir = join(directory, ".git");
+  if (!existsSync(gitDir)) {
+    return false;
+  }
+  const stats = statSync(gitDir);
+  if (!stats.isDirectory()) {
+    return false;
+  }
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd: directory });
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+async function gitProcess({ files, nextTag, commitMessage, skipHooks, dryRun }) {
+  try {
+    if (!isGitRepository(cwd2())) {
+      throw new Error("Not a git repository (or any parent up to mount point /)");
+    }
+    if (!dryRun) {
+      await gitAdd(files);
+      await gitCommit({
+        message: commitMessage,
+        skipHooks
+      });
+      const tagMessage = `New Version ${nextTag} generated at ${new Date().toISOString()}`;
+      await createGitTag({
+        tag: nextTag,
+        message: tagMessage
+      });
+    } else {
+      log("info", "[DRY RUN] Would add files:");
+      for (const file of files) {
+        log("info", `  - ${file}`);
+      }
+      log("info", `[DRY RUN] Would commit with message: "${commitMessage}"`);
+      log("info", `[DRY RUN] Would create tag: ${nextTag}`);
+    }
+  } catch (err) {
+    console.log(err);
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to create new version: ${errorMessage}`);
+  }
+}
+async function lastMergeBranchName(branches, baseBranch) {
+  try {
+    const branchesRegex = `${branches.join("/(.*)|")}/(.*)`;
+    const command = `git for-each-ref --sort=-committerdate --format='%(refname:short)' refs/heads --merged ${baseBranch} | grep -o -i -E "${branchesRegex}" | awk -F'[ ]' '{print $1}' | head -n 1`;
+    const { stdout } = await execAsync(command);
+    return stdout.trim();
+  } catch (error) {
+    console.error(
+      "Error while getting the last branch name:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+function getCurrentBranch() {
+  const result = execSync("git rev-parse --abbrev-ref HEAD");
+  return result.toString().trim();
+}
+
+// src/utils.ts
+function log(status, message) {
+  const statusColors = {
+    info: chalk.blue("\u2139"),
+    success: chalk.green("\u2713"),
+    error: chalk.red("\u2717"),
+    warning: chalk.yellow("\u26A0")
+  };
+  process.stdout.write(`${statusColors[status]} ${message}
+`);
+}
+async function getLatestTag() {
+  try {
+    const tags = await getSemverTags({});
+    return tags[0] || "";
+  } catch (error) {
+    log("error", "Failed to get latest tag");
+    console.error(error);
+    if (error instanceof Error && error.message.includes("No names found")) {
+      log("info", "No tags found in the repository.");
+    }
+    return "";
+  }
+}
+function formatTag(options, props) {
+  const { name: name2, synced, tagPrefix } = options;
+  const { version } = props;
+  if (!synced && name2) {
+    return `${tagPrefix ? tagPrefix : ""}${name2}@${version}`;
+  }
+  return `${tagPrefix ? tagPrefix : "v"}${version}`;
+}
+function formatTagPrefix(tagPrefix) {
+  return tagPrefix ? `${tagPrefix}@` : "";
+}
+function createTemplateString(template, data) {
+  return template.replace(/\$\{([^}]+)\}/g, (_, key) => data[key] || "");
+}
+function formatCommitMessage(template, version) {
+  return createTemplateString(template, { version });
+}
+function updatePackageVersion({ path: path2, version, name: name2, dryRun }) {
+  try {
+    const pkgPath = `${path2}/package.json`;
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+    pkg.version = version;
+    if (!dryRun) {
+      fs2.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+      log("success", `${name2}: ${version}`);
+    } else {
+      log("info", `[DRY RUN] Would update ${name2} package.json to version ${version}`);
+    }
+  } catch (error) {
+    log("error", `Failed to update ${name2} to version ${version}`);
+    console.error(error);
+  }
+}
+
+// src/versionEngine.ts
+import fs3 from "fs";
+import path from "path";
+import { cwd as cwd3, exit } from "process";
+import { getPackagesSync } from "@manypkg/get-packages";
+import { Bumper } from "conventional-recommended-bump";
+import semver from "semver";
+var VersionEngine = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async calculateVersion(options) {
+    const { latestTag, type, path: path2, name: name2, branchPattern, prereleaseIdentifier } = options;
+    const originalPrefix = this.config.tagPrefix || "";
+    const initialVersion = prereleaseIdentifier ? `0.0.1-${prereleaseIdentifier}` : "0.0.1";
+    const tagSearchPattern = name2 ? originalPrefix ? `${originalPrefix}${name2}@` : `${name2}@` : originalPrefix ? `${originalPrefix}v` : "v";
+    let determinedReleaseType = type || null;
+    if (determinedReleaseType) {
+      if (!latestTag) {
+        return initialVersion;
+      }
+      const currentVersion = semver.clean(latestTag.replace(tagSearchPattern, "")) || "0.0.0";
+      return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+    }
+    if (this.config.versionStrategy === "branchPattern" && (branchPattern == null ? void 0 : branchPattern.length)) {
+      const currentBranch = await getCurrentBranch();
+      const mergeBranch = await lastMergeBranchName(branchPattern, this.config.baseBranch);
+      const branch = mergeBranch || currentBranch;
+      for (const pattern of branchPattern) {
+        const [match, releaseType] = pattern.split(":");
+        if (branch.includes(match) && releaseType) {
+          determinedReleaseType = releaseType;
+          break;
+        }
+      }
+      if (determinedReleaseType) {
+        if (!latestTag) {
+          return initialVersion;
+        }
+        const currentVersion = semver.clean(latestTag.replace(tagSearchPattern, "")) || "0.0.0";
+        return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+      }
+    }
+    try {
+      const bumper = new Bumper();
+      bumper.loadPreset(this.config.preset);
+      const recommendedBump = await bumper.bump();
+      const releaseTypeFromCommits = recommendedBump.releaseType;
+      if (!latestTag) {
+        return initialVersion;
+      }
+      const checkPath = path2 || cwd3();
+      const commitsLength = await getCommitsLength(checkPath);
+      if (commitsLength === 0) {
+        log(
+          "info",
+          `No new commits found for ${name2 || "project"} since ${latestTag}, skipping version bump`
+        );
+        return "";
+      }
+      if (!releaseTypeFromCommits) {
+        log(
+          "info",
+          `No relevant commits found for ${name2 || "project"} since ${latestTag}, skipping version bump`
+        );
+        return "";
+      }
+      const currentVersion = semver.clean(latestTag.replace(tagSearchPattern, "")) || "0.0.0";
+      return semver.inc(currentVersion, releaseTypeFromCommits, prereleaseIdentifier) || "";
+    } catch (error) {
+      log("error", `Failed to calculate version for ${name2 || "project"}`);
+      console.error(error);
+      if (error instanceof Error && error.message.includes("No names found")) {
+        log("info", "No tags found, proceeding with initial version calculation (if applicable).");
+        return initialVersion;
+      }
+      return "";
+    }
+  }
+  async processPackages(packages = [], configPackages = []) {
+    const { tagPrefix } = this.config;
+    const pkgsResult = packages.length ? { packages } : getPackagesSync(cwd3());
+    const files = [];
+    const selectedPackages = pkgsResult.packages.filter((pkg) => {
+      var _a;
+      if ((_a = this.config.skip) == null ? void 0 : _a.includes(pkg.packageJson.name)) {
+        return false;
+      }
+      return configPackages.length === 0 || configPackages.includes(pkg.packageJson.name);
+    });
+    for (const pkg of selectedPackages) {
+      const name2 = pkg.packageJson.name;
+      const pkgPath = pkg.dir;
+      const prefix = formatTagPrefix(tagPrefix);
+      const latestTag = await getLatestTag();
+      const nextVersion = await this.calculateVersion({
+        latestTag,
+        tagPrefix: prefix,
+        path: pkgPath,
+        name: name2,
+        branchPattern: this.config.branchPattern,
+        baseBranch: this.config.baseBranch,
+        prereleaseIdentifier: this.config.prereleaseIdentifier
+      });
+      if (!nextVersion) {
+        continue;
+      }
+      updatePackageVersion({
+        path: pkgPath,
+        version: nextVersion,
+        name: name2,
+        dryRun: this.config.dryRun
+      });
+      files.push(path.join(pkgPath, "package.json"));
+    }
+    return files;
+  }
+  async createGitCommitAndTag(files, nextTag, commitMessage, dryRun) {
+    try {
+      await gitProcess({
+        files,
+        nextTag,
+        commitMessage,
+        skipHooks: this.config.skipHooks,
+        dryRun
+      });
+      if (!dryRun) {
+        log("success", `Created tag: ${nextTag}`);
+      }
+    } catch (error) {
+      log("error", "Failed to create git commit and tag");
+      console.error(error);
+      exit(1);
+    }
+  }
+  async syncedStrategy() {
+    var _a;
+    const {
+      tagPrefix,
+      baseBranch,
+      branchPattern,
+      commitMessage = "chore(release): v${version}",
+      prereleaseIdentifier
+    } = this.config;
+    const prefix = formatTagPrefix(tagPrefix);
+    const latestTag = await getLatestTag();
+    const nextVersion = await this.calculateVersion({
+      latestTag,
+      tagPrefix: prefix,
+      branchPattern,
+      baseBranch,
+      prereleaseIdentifier
+    });
+    if (!nextVersion) {
+      log("info", "No version change needed");
+      return;
+    }
+    let pkgsResult;
+    try {
+      pkgsResult = getPackagesSync(cwd3());
+      if (!pkgsResult || !pkgsResult.packages) {
+        throw new Error("Failed to get packages information");
+      }
+    } catch (error) {
+      log("error", "Failed to get packages information");
+      console.error(error);
+      exit(1);
+      return;
+    }
+    const files = [];
+    try {
+      const rootPkgPath = path.join(pkgsResult.root, "package.json");
+      if (fs3.existsSync(rootPkgPath)) {
+        updatePackageVersion({
+          path: pkgsResult.root,
+          version: nextVersion,
+          name: "root",
+          dryRun: this.config.dryRun
+        });
+        files.push(rootPkgPath);
+      }
+    } catch (_error) {
+      log("error", "Failed to update root package.json");
+    }
+    for (const pkg of pkgsResult.packages) {
+      if ((_a = this.config.skip) == null ? void 0 : _a.includes(pkg.packageJson.name)) {
+        continue;
+      }
+      updatePackageVersion({
+        path: pkg.dir,
+        version: nextVersion,
+        name: pkg.packageJson.name,
+        dryRun: this.config.dryRun
+      });
+      files.push(path.join(pkg.dir, "package.json"));
+    }
+    const nextTag = formatTag(
+      { synced: true, tagPrefix },
+      { tagPrefix: prefix, version: nextVersion }
+    );
+    const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
+    await this.createGitCommitAndTag(files, nextTag, formattedCommitMessage, this.config.dryRun);
+  }
+  async singleStrategy() {
+    const {
+      packages: configPackages,
+      tagPrefix,
+      commitMessage = "chore(release): ${version}"
+    } = this.config;
+    if (configPackages.length !== 1) {
+      log("error", "Single mode requires exactly one package name");
+      exit(1);
+    }
+    const packageName = configPackages[0];
+    let pkgsResult;
+    try {
+      pkgsResult = getPackagesSync(cwd3());
+      if (!pkgsResult || !pkgsResult.packages) {
+        throw new Error("Failed to get packages information");
+      }
+    } catch (error) {
+      log("error", "Failed to get packages information");
+      console.error(error);
+      exit(1);
+      return;
+    }
+    const pkg = pkgsResult.packages.find((p) => p.packageJson.name === packageName);
+    if (!pkg) {
+      log("error", `Package ${packageName} not found`);
+      exit(1);
+    }
+    const pkgPath = pkg.dir;
+    const prefix = formatTagPrefix(tagPrefix);
+    const latestTag = await getLatestTag();
+    const nextVersion = await this.calculateVersion({
+      latestTag,
+      tagPrefix: prefix,
+      path: pkgPath,
+      name: packageName
+    });
+    if (!nextVersion) {
+      log("info", `No version change needed for ${packageName}`);
+      return;
+    }
+    updatePackageVersion({
+      path: pkgPath,
+      version: nextVersion,
+      name: packageName,
+      dryRun: this.config.dryRun
+    });
+    const nextTag = formatTag(
+      { tagPrefix, name: packageName, synced: false },
+      { tagPrefix: prefix, version: nextVersion }
+    );
+    const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
+    await this.createGitCommitAndTag(
+      [path.join(pkgPath, "package.json")],
+      nextTag,
+      formattedCommitMessage,
+      this.config.dryRun
+    );
+  }
+  async asyncStrategy() {
+    const {
+      packages: configPackages,
+      commitMessage = "chore(release): ${version}",
+      skipHooks
+    } = this.config;
+    let pkgsResult;
+    try {
+      pkgsResult = getPackagesSync(cwd3());
+      if (!pkgsResult || !pkgsResult.packages) {
+        throw new Error("Failed to get packages information");
+      }
+    } catch (error) {
+      log("error", "Failed to get packages information");
+      console.error(error);
+      exit(1);
+      return;
+    }
+    const pkgsToProcess = await this.processPackages(pkgsResult.packages, configPackages);
+    if (pkgsToProcess.length === 0) {
+      log("info", "No packages to process");
+      return;
+    }
+    const formattedCommitMessage = commitMessage;
+    try {
+      await gitProcess({
+        files: pkgsToProcess,
+        nextTag: "",
+        commitMessage: formattedCommitMessage,
+        skipHooks,
+        dryRun: this.config.dryRun
+      });
+      if (!this.config.dryRun) {
+        log("success", "Created version commit");
+      }
+    } catch (error) {
+      log("error", "Failed to create version commit");
+      console.error(error);
+      exit(1);
+    }
+  }
+};
+
+// src/index.ts
+var name = "package-versioner";
+var program = new Command();
+program.name("package-versioner").description("Manages package versions using Git context.").version(package_default.version);
+program.option("-t, --target <project>", "specific package to update").option("-b, --bump <version>", "type of version bump to perform", (value) => {
+  const validBumps = [
+    "patch",
+    "minor",
+    "major",
+    "premajor",
+    "preminor",
+    "prepatch",
+    "prerelease"
+  ];
+  if (!validBumps.includes(value)) {
+    log("error", `Invalid bump type '${value}'. Valid options are: ${validBumps.join(", ")}`);
+    process.exit(1);
+  }
+  return value;
+}).option("--base-branch <branch>", "override the base branch for this operation").option("--synced", "force synced versioning mode").option("--no-synced", "force async versioning mode").option(
+  "--skip <packages>",
+  "comma-separated list of packages to skip",
+  (value) => value.split(",")
+).option("--prerelease <identifier>", "set prerelease identifier (e.g., alpha, beta)").option("--skip-hooks", "skip Git hooks for this operation").option("--config <path>", "specify a custom config file path").option("--dry-run", "Calculate version and log actions without changing files or Git state");
+program.description("Version packages based on Git context and conventional commits").action(async (options) => {
+  const figletText = figlet.textSync(name);
+  const versionText = `v${package_default.version}`;
+  process.stdout.write(`${chalk2.hex("#FF1F57")(figletText)}
+`);
+  process.stdout.write(`${chalk2.hex("#0096FF")(versionText)}
+
+`);
+  try {
+    const configPath = options.config || void 0;
+    const config = await loadConfig(configPath);
+    if (options.baseBranch)
+      config.baseBranch = options.baseBranch;
+    if (options.synced !== void 0)
+      config.synced = options.synced;
+    if (options.skip)
+      config.skip = options.skip;
+    if (options.prerelease)
+      config.prereleaseIdentifier = options.prerelease;
+    if (options.skipHooks !== void 0)
+      config.skipHooks = options.skipHooks;
+    if (options.dryRun !== void 0)
+      config.dryRun = options.dryRun;
+    const engine = new VersionEngine(config);
+    if (config.synced) {
+      await engine.syncedStrategy();
+    } else if (options.bump && options.target) {
+      await engine.singleStrategy();
+    } else {
+      await engine.asyncStrategy();
+    }
+  } catch (err) {
+    log("error", `${err instanceof Error ? err.message : String(err)}`);
+    exit2(1);
+  }
+});
+program.parse();