package-versioner 0.1.1 → 0.2.0

package/README.md

@@ -45,7 +45,7 @@ npx package-versioner -t @scope/package-a,@scope/package-b
 npx package-versioner --dry-run
 ```
 
-
+**Note on Targeting:** Using the `-t` flag creates package-specific tags (e.g., `@scope/package-a@1.2.0`) but *not* a global tag (like `v1.2.0`). If needed, create the global tag manually in your CI/CD script after this command.
 
 ## Configuration
 

package/dist/index.cjs

@@ -58,7 +58,7 @@ var import_figlet = __toESM(require("figlet"), 1);
 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.1.0",
+  version: "0.1.1",
   type: "module",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
@@ -72,17 +72,9 @@ var package_default = {
     url: "https://github.com/goosewobbler/package-versioner",
     homepage: "https://github.com/goosewobbler/package-versioner"
   },
-  keywords: [
-    "version",
-    "semver",
-    "git",
-    "package"
-  ],
+  keywords: ["version", "semver", "git", "package"],
   license: "MIT",
-  files: [
-    "dist/**",
-    "package-versioner.schema.json"
-  ],
+  files: ["dist/**", "docs/**", "package-versioner.schema.json"],
   bin: {
     "package-versioner": "./dist/index.js"
   },
@@ -100,10 +92,7 @@ var package_default = {
     prepare: "husky"
   },
   "lint-staged": {
-    "*.{js,ts,jsx,tsx}": [
-      "biome check --apply",
-      "biome format --write"
-    ]
+    "*.{js,ts,jsx,tsx}": ["biome check --apply", "biome format --write"]
   },
   devDependencies: {
     "@biomejs/biome": "^1.9.4",
@@ -425,7 +414,7 @@ var VersionEngine = class {
    * Returns a list of package.json file paths that were updated (or would be in dry run).
    */
   async processPackages(discoveredPackages = [], targets = []) {
-    const { tagPrefix, skip } = this.config;
+    const { tagPrefix, skip, dryRun } = this.config;
     const files = [];
     const pkgsToConsider = discoveredPackages.filter((pkg) => {
       if (skip == null ? void 0 : skip.includes(pkg.packageJson.name)) {
@@ -448,16 +437,13 @@ var VersionEngine = class {
       const latestTag = await getLatestTag();
       const nextVersion = await this.calculateVersion({
         latestTag,
-        // This might need refinement for async based on package-specific tags
         tagPrefix: prefix,
         path: pkgPath,
         name,
-        // Pass name for potential package-specific tag lookups
         branchPattern: this.config.branchPattern,
         baseBranch: this.config.baseBranch,
         prereleaseIdentifier: this.config.prereleaseIdentifier,
         type: this.config.forceType
-        // Pass forced type if provided
       });
       if (!nextVersion) {
         continue;
@@ -466,7 +452,7 @@ var VersionEngine = class {
         path: pkgPath,
         version: nextVersion,
         name,
-        dryRun: this.config.dryRun
+        dryRun
       });
       files.push(import_node_path2.default.join(pkgPath, "package.json"));
     }
@@ -598,13 +584,19 @@ var VersionEngine = class {
     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) {
+    let nextVersion = void 0;
+    try {
+      nextVersion = await this.calculateVersion({
+        latestTag,
+        tagPrefix: prefix,
+        path: pkgPath,
+        name: packageName
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log("error", `Failed to calculate version for ${packageName}: ${errorMessage}`);
+    }
+    if (nextVersion === void 0 || nextVersion === "") {
       log("info", `No version change needed for ${packageName}`);
       return;
     }
@@ -630,11 +622,14 @@ var VersionEngine = class {
    * Async versioning strategy (each package gets its own version)
    */
   async asyncStrategy(cliTargets = []) {
+    if (cliTargets.length > 0) {
+      await this.asyncTargetedStrategy(cliTargets);
+      return;
+    }
     const {
       commitMessage = "chore(release): ${version}",
       // Align with test expectations
       skipHooks
-      // Add skipHooks here
     } = this.config;
     let pkgsResult;
     try {
@@ -658,6 +653,7 @@ var VersionEngine = class {
       await gitProcess({
         files: pkgsToProcess,
         nextTag: "",
+        // No tag for default async
         commitMessage: formattedCommitMessage,
         skipHooks,
         dryRun: this.config.dryRun
@@ -671,6 +667,121 @@ var VersionEngine = class {
       (0, import_node_process3.exit)(1);
     }
   }
+  // --- NEW METHOD for Async + Targeted ---
+  async asyncTargetedStrategy(cliTargets) {
+    var _a;
+    const {
+      tagPrefix,
+      skip,
+      dryRun,
+      skipHooks,
+      commitMessage: commitMessageTemplate
+    } = this.config;
+    const updatedPackagesInfo = [];
+    log("info", `Processing targeted packages: ${cliTargets.join(", ")}`);
+    let pkgsResult;
+    try {
+      pkgsResult = (0, import_get_packages.getPackagesSync)((0, import_node_process3.cwd)());
+      if (!pkgsResult || !pkgsResult.packages) {
+        throw new Error("Failed to get packages information");
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log("error", `Failed to get packages information: ${errorMessage}`);
+      (0, import_node_process3.exit)(1);
+    }
+    const pkgsToConsider = pkgsResult.packages.filter((pkg) => {
+      if (skip == null ? void 0 : skip.includes(pkg.packageJson.name)) {
+        log("info", `Skipping package ${pkg.packageJson.name} based on config skip list.`);
+        return false;
+      }
+      const isTargeted = cliTargets.includes(pkg.packageJson.name);
+      if (!isTargeted) {
+      }
+      return isTargeted;
+    });
+    log("info", `Found ${pkgsToConsider.length} targeted package(s) to process after filtering.`);
+    if (pkgsToConsider.length === 0) {
+      log("info", "No matching targeted packages found to process.");
+      return;
+    }
+    for (const pkg of pkgsToConsider) {
+      const name = 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,
+        branchPattern: this.config.branchPattern,
+        baseBranch: this.config.baseBranch,
+        prereleaseIdentifier: this.config.prereleaseIdentifier,
+        type: this.config.forceType
+      });
+      if (!nextVersion) {
+        continue;
+      }
+      updatePackageVersion({
+        path: pkgPath,
+        version: nextVersion,
+        name,
+        dryRun
+      });
+      const packageTag = formatTag(
+        { synced: false, name, tagPrefix },
+        { version: nextVersion, tagPrefix }
+      );
+      const tagMessage = `chore(release): ${name} ${nextVersion}`;
+      if (!dryRun) {
+        try {
+          await createGitTag({ tag: packageTag, message: tagMessage });
+          log("success", `Created tag: ${packageTag}`);
+        } catch (tagError) {
+          log(
+            "error",
+            `Failed to create tag ${packageTag} for ${name}: ${tagError.message}`
+          );
+          log("error", tagError.stack || "No stack trace available");
+        }
+      } else {
+        log("info", `[DRY RUN] Would create tag: ${packageTag}`);
+      }
+      updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
+    }
+    if (updatedPackagesInfo.length === 0) {
+      log("info", "No targeted packages required a version update.");
+      return;
+    }
+    const filesToCommit = updatedPackagesInfo.map((info) => import_node_path2.default.join(info.path, "package.json"));
+    const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
+    const representativeVersion = ((_a = updatedPackagesInfo[0]) == null ? void 0 : _a.version) || "multiple";
+    let commitMessage = commitMessageTemplate || "chore(release): publish packages";
+    if (updatedPackagesInfo.length === 1 && commitMessage.includes("${version}")) {
+      commitMessage = formatCommitMessage(commitMessage, representativeVersion);
+    } else {
+      commitMessage = `chore(release): ${packageNames} ${representativeVersion}`;
+    }
+    commitMessage += " [skip-ci]";
+    if (!dryRun) {
+      try {
+        await gitAdd(filesToCommit);
+        await gitCommit({ message: commitMessage, skipHooks });
+        log("success", `Created commit for targeted release: ${packageNames}`);
+      } catch (commitError) {
+        log("error", "Failed to create commit for targeted release.");
+        console.error(commitError);
+        (0, import_node_process3.exit)(1);
+      }
+    } else {
+      log("info", "[DRY RUN] Would add files:");
+      for (const file of filesToCommit) {
+        log("info", `  - ${file}`);
+      }
+      log("info", `[DRY RUN] Would commit with message: "${commitMessage}"`);
+    }
+  }
 };
 
 // src/index.ts

package/dist/index.js

@@ -35,7 +35,7 @@ import figlet from "figlet";
 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.1.0",
+  version: "0.1.1",
   type: "module",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
@@ -49,17 +49,9 @@ var package_default = {
     url: "https://github.com/goosewobbler/package-versioner",
     homepage: "https://github.com/goosewobbler/package-versioner"
   },
-  keywords: [
-    "version",
-    "semver",
-    "git",
-    "package"
-  ],
+  keywords: ["version", "semver", "git", "package"],
   license: "MIT",
-  files: [
-    "dist/**",
-    "package-versioner.schema.json"
-  ],
+  files: ["dist/**", "docs/**", "package-versioner.schema.json"],
   bin: {
     "package-versioner": "./dist/index.js"
   },
@@ -77,10 +69,7 @@ var package_default = {
     prepare: "husky"
   },
   "lint-staged": {
-    "*.{js,ts,jsx,tsx}": [
-      "biome check --apply",
-      "biome format --write"
-    ]
+    "*.{js,ts,jsx,tsx}": ["biome check --apply", "biome format --write"]
   },
   devDependencies: {
     "@biomejs/biome": "^1.9.4",
@@ -402,7 +391,7 @@ var VersionEngine = class {
    * Returns a list of package.json file paths that were updated (or would be in dry run).
    */
   async processPackages(discoveredPackages = [], targets = []) {
-    const { tagPrefix, skip } = this.config;
+    const { tagPrefix, skip, dryRun } = this.config;
     const files = [];
     const pkgsToConsider = discoveredPackages.filter((pkg) => {
       if (skip == null ? void 0 : skip.includes(pkg.packageJson.name)) {
@@ -425,16 +414,13 @@ var VersionEngine = class {
       const latestTag = await getLatestTag();
       const nextVersion = await this.calculateVersion({
         latestTag,
-        // This might need refinement for async based on package-specific tags
         tagPrefix: prefix,
         path: pkgPath,
         name,
-        // Pass name for potential package-specific tag lookups
         branchPattern: this.config.branchPattern,
         baseBranch: this.config.baseBranch,
         prereleaseIdentifier: this.config.prereleaseIdentifier,
         type: this.config.forceType
-        // Pass forced type if provided
       });
       if (!nextVersion) {
         continue;
@@ -443,7 +429,7 @@ var VersionEngine = class {
         path: pkgPath,
         version: nextVersion,
         name,
-        dryRun: this.config.dryRun
+        dryRun
       });
       files.push(path.join(pkgPath, "package.json"));
     }
@@ -575,13 +561,19 @@ var VersionEngine = class {
     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) {
+    let nextVersion = void 0;
+    try {
+      nextVersion = await this.calculateVersion({
+        latestTag,
+        tagPrefix: prefix,
+        path: pkgPath,
+        name: packageName
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log("error", `Failed to calculate version for ${packageName}: ${errorMessage}`);
+    }
+    if (nextVersion === void 0 || nextVersion === "") {
       log("info", `No version change needed for ${packageName}`);
       return;
     }
@@ -607,11 +599,14 @@ var VersionEngine = class {
    * Async versioning strategy (each package gets its own version)
    */
   async asyncStrategy(cliTargets = []) {
+    if (cliTargets.length > 0) {
+      await this.asyncTargetedStrategy(cliTargets);
+      return;
+    }
     const {
       commitMessage = "chore(release): ${version}",
       // Align with test expectations
       skipHooks
-      // Add skipHooks here
     } = this.config;
     let pkgsResult;
     try {
@@ -635,6 +630,7 @@ var VersionEngine = class {
       await gitProcess({
         files: pkgsToProcess,
         nextTag: "",
+        // No tag for default async
         commitMessage: formattedCommitMessage,
         skipHooks,
         dryRun: this.config.dryRun
@@ -648,6 +644,121 @@ var VersionEngine = class {
       exit(1);
     }
   }
+  // --- NEW METHOD for Async + Targeted ---
+  async asyncTargetedStrategy(cliTargets) {
+    var _a;
+    const {
+      tagPrefix,
+      skip,
+      dryRun,
+      skipHooks,
+      commitMessage: commitMessageTemplate
+    } = this.config;
+    const updatedPackagesInfo = [];
+    log("info", `Processing targeted packages: ${cliTargets.join(", ")}`);
+    let pkgsResult;
+    try {
+      pkgsResult = getPackagesSync(cwd3());
+      if (!pkgsResult || !pkgsResult.packages) {
+        throw new Error("Failed to get packages information");
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log("error", `Failed to get packages information: ${errorMessage}`);
+      exit(1);
+    }
+    const pkgsToConsider = pkgsResult.packages.filter((pkg) => {
+      if (skip == null ? void 0 : skip.includes(pkg.packageJson.name)) {
+        log("info", `Skipping package ${pkg.packageJson.name} based on config skip list.`);
+        return false;
+      }
+      const isTargeted = cliTargets.includes(pkg.packageJson.name);
+      if (!isTargeted) {
+      }
+      return isTargeted;
+    });
+    log("info", `Found ${pkgsToConsider.length} targeted package(s) to process after filtering.`);
+    if (pkgsToConsider.length === 0) {
+      log("info", "No matching targeted packages found to process.");
+      return;
+    }
+    for (const pkg of pkgsToConsider) {
+      const name = 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,
+        branchPattern: this.config.branchPattern,
+        baseBranch: this.config.baseBranch,
+        prereleaseIdentifier: this.config.prereleaseIdentifier,
+        type: this.config.forceType
+      });
+      if (!nextVersion) {
+        continue;
+      }
+      updatePackageVersion({
+        path: pkgPath,
+        version: nextVersion,
+        name,
+        dryRun
+      });
+      const packageTag = formatTag(
+        { synced: false, name, tagPrefix },
+        { version: nextVersion, tagPrefix }
+      );
+      const tagMessage = `chore(release): ${name} ${nextVersion}`;
+      if (!dryRun) {
+        try {
+          await createGitTag({ tag: packageTag, message: tagMessage });
+          log("success", `Created tag: ${packageTag}`);
+        } catch (tagError) {
+          log(
+            "error",
+            `Failed to create tag ${packageTag} for ${name}: ${tagError.message}`
+          );
+          log("error", tagError.stack || "No stack trace available");
+        }
+      } else {
+        log("info", `[DRY RUN] Would create tag: ${packageTag}`);
+      }
+      updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
+    }
+    if (updatedPackagesInfo.length === 0) {
+      log("info", "No targeted packages required a version update.");
+      return;
+    }
+    const filesToCommit = updatedPackagesInfo.map((info) => path.join(info.path, "package.json"));
+    const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
+    const representativeVersion = ((_a = updatedPackagesInfo[0]) == null ? void 0 : _a.version) || "multiple";
+    let commitMessage = commitMessageTemplate || "chore(release): publish packages";
+    if (updatedPackagesInfo.length === 1 && commitMessage.includes("${version}")) {
+      commitMessage = formatCommitMessage(commitMessage, representativeVersion);
+    } else {
+      commitMessage = `chore(release): ${packageNames} ${representativeVersion}`;
+    }
+    commitMessage += " [skip-ci]";
+    if (!dryRun) {
+      try {
+        await gitAdd(filesToCommit);
+        await gitCommit({ message: commitMessage, skipHooks });
+        log("success", `Created commit for targeted release: ${packageNames}`);
+      } catch (commitError) {
+        log("error", "Failed to create commit for targeted release.");
+        console.error(commitError);
+        exit(1);
+      }
+    } else {
+      log("info", "[DRY RUN] Would add files:");
+      for (const file of filesToCommit) {
+        log("info", `  - ${file}`);
+      }
+      log("info", `[DRY RUN] Would commit with message: "${commitMessage}"`);
+    }
+  }
 };
 
 // src/index.ts

package/docs/VERSIONING_STRATEGIES.md

@@ -0,0 +1,96 @@
+# Versioning Strategies and Concepts
+
+`package-versioner` offers flexible ways to determine the next version for your project based on its history and your configuration.
+
+## How the Next Version is Calculated
+
+There are two primary methods the tool uses to decide the version bump (e.g., patch, minor, major), configured via the `versionStrategy` option in `version.config.json`:
+
+### 1. Conventional Commits (`versionStrategy: "conventional"`)
+
+This is the default strategy. `package-versioner` analyzes Git commit messages since the last Git tag that follows semver patterns. It uses the [conventional-commits](https://www.conventionalcommits.org/) specification to determine the bump:
+
+-   **Patch Bump (e.g., 1.2.3 -> 1.2.4):** Triggered by `fix:` commit types.
+-   **Minor Bump (e.g., 1.2.3 -> 1.3.0):** Triggered by `feat:` commit types.
+-   **Major Bump (e.g., 1.2.3 -> 2.0.0):** Triggered by commits with `BREAKING CHANGE:` in the footer or `feat!:`, `fix!:` etc. in the header.
+
+The specific preset used for analysis (e.g., "angular", "conventional") can be set using the `preset` option in `version.config.json`.
+
+**Format:** `<type>(<scope>): <subject>`
+
+`<scope>` is optional.
+
+**Example Commit Types:**
+
+-   `feat:` (new feature for the user)
+-   `fix:` (bug fix for the user)
+-   `docs:` (changes to the documentation)
+-   `style:` (formatting, missing semi-colons, etc; no production code change)
+-   `refactor:` (refactoring production code, e.g. renaming a variable)
+-   `test:` (adding missing tests, refactoring tests; no production code change)
+-   `chore:` (updating build tasks etc; no production code change)
+
+**References:**
+
+-   [https://www.conventionalcommits.org/](https://www.conventionalcommits.org/)
+-   [https://github.com/conventional-changelog/conventional-changelog](https://github.com/conventional-changelog/conventional-changelog)
+
+### 2. Branch Pattern (`versionStrategy: "branchPattern"`)
+
+This strategy uses the name of the current Git branch (or the most recently merged branch matching a pattern, if applicable) to determine the version bump.
+
+You define patterns in the `branchPattern` array in `version.config.json`. Each pattern is a string like `"prefix:bumptype"`.
+
+**Example `version.config.json`:**
+
+```json
+{
+  "versionStrategy": "branchPattern",
+  "branchPattern": [
+    "feature:minor",
+    "hotfix:patch",
+    "fix:patch",
+    "release:major" 
+  ],
+  "baseBranch": "main" 
+}
+```
+
+**How it works:**
+
+1.  The tool checks the current branch name.
+2.  It might also look for the most recently merged branch into `baseBranch` that matches any pattern in `branchPattern`.
+3.  It compares the relevant branch name (current or last merged) against the prefixes in `branchPattern`.
+4.  If a match is found (e.g., current branch is `feature/add-login`), it applies the corresponding bump type (`minor` in this case).
+
+This allows you to enforce version bumps based on your branching workflow (e.g., all branches starting with `feature/` result in a minor bump).
+
+## Monorepo Versioning Modes
+
+While primarily used for single packages now, `package-versioner` retains options for monorepo workflows, controlled mainly by the `synced` flag in `version.config.json`.
+
+### Synced Mode (`synced: true`)
+
+This is the default if the `synced` flag is present and true.
+
+-   **Behavior:** The tool calculates **one** version bump based on the overall history (or branch pattern). This single new version is applied to **all** packages within the repository (or just the root `package.json` if not a structured monorepo). A single Git tag is created (e.g., `v1.2.3`).
+-   **Use Case:** Suitable for monorepos where all packages are tightly coupled and released together with the same version number. Also the effective mode for single-package repositories.
+
+### Async Mode (`synced: false`)
+
+*(Note: This mode relies heavily on monorepo tooling and structure, like `pnpm workspaces` and correctly configured package dependencies.)*
+
+-   **Behavior (Default - No `-t` flag):** The tool analyzes commits to determine which specific packages within the monorepo have changed since the last relevant commit/tag.
+    -   It calculates an appropriate version bump **independently for each changed package** based on the commits affecting that package.
+    -   Only the `package.json` files of the changed packages are updated.
+    -   A **single commit** is created grouping all the version bumps, using the commit message template. **No Git tags are created** in this mode.
+-   **Use Case:** Suitable for monorepos where packages are versioned independently, but a single commit represents the batch of updates for traceability.
+
+-   **Behavior (Targeted - With `-t` flag):** When using the `-t, --target <targets>` flag:
+    -   Only the specified packages (respecting the `skip` list) are considered for versioning.
+    -   It calculates an appropriate version bump **independently for each targeted package** based on its commit history.
+    -   The `package.json` file of each successfully updated targeted package is modified.
+    -   An **individual Git tag** (e.g., `packageName@1.2.3`) is created **for each successfully updated package** immediately after its version is bumped.
+    -   Finally, a **single commit** is created including all the updated `package.json` files, using a summary commit message (e.g., `chore(release): pkg-a, pkg-b 1.2.3 [skip-ci]`).
+    -   **Important:** Only package-specific tags are created. The global tag (e.g., `v1.2.3`) is **not** automatically generated in this mode. If your release process (like GitHub Releases) depends on a global tag, you'll need to create it manually in your CI/CD script *after* `package-versioner` completes.
+-   **Use Case:** Releasing specific packages independently while still tagging each released package individually.

package/package.json

@@ -1,7 +1,7 @@
 {
   "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.1.1",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -24,6 +24,7 @@
   "license": "MIT",
   "files": [
     "dist/**",
+    "docs/**",
     "package-versioner.schema.json"
   ],
   "bin": {