@releasekit/version 0.3.0 → 0.4.0

package/dist/cli.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+
+declare function createVersionCommand(): Command;
+declare function createVersionProgram(): Command;
+
+export { createVersionCommand, createVersionProgram };

package/dist/cli.js

@@ -1 +1,105 @@
 #!/usr/bin/env node
+import {
+  VersionEngine,
+  enableJsonOutput,
+  loadConfig,
+  log,
+  printJsonOutput
+} from "./chunk-ZTFI7TXV.js";
+import {
+  readPackageVersion
+} from "./chunk-2MN2VLZF.js";
+import "./chunk-LMPZV35Z.js";
+
+// src/cli.ts
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+function createVersionCommand() {
+  return new Command("version").description("Version a package or packages based on configuration").option("-c, --config <path>", "Path to config file (defaults to releasekit.config.json in current directory)").option("-d, --dry-run", "Dry run (no changes made)", false).option("-b, --bump <type>", "Specify bump type (patch|minor|major)").option("-p, --prerelease [identifier]", "Create prerelease version").option("-s, --sync", "Use synchronized versioning across all packages").option("-j, --json", "Output results as JSON", false).option("-t, --target <packages>", "Comma-delimited list of package names to target").option("--project-dir <path>", "Project directory to run commands in", process.cwd()).action(async (options) => {
+    if (options.json) {
+      enableJsonOutput(options.dryRun);
+    }
+    try {
+      const originalCwd = process.cwd();
+      if (options.projectDir && options.projectDir !== originalCwd) {
+        try {
+          process.chdir(options.projectDir);
+          log(`Changed working directory to: ${options.projectDir}`, "debug");
+        } catch (error) {
+          throw new Error(
+            `Failed to change to directory "${options.projectDir}": ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      const config = loadConfig({ cwd: options.projectDir, configPath: options.config });
+      log(`Loaded configuration from ${options.config || "releasekit.config.json"}`, "info");
+      if (options.dryRun) config.dryRun = true;
+      if (options.sync) config.sync = true;
+      if (options.bump) config.type = options.bump;
+      if (options.prerelease) {
+        config.prereleaseIdentifier = options.prerelease === true ? "next" : options.prerelease;
+        config.isPrerelease = true;
+      }
+      const cliTargets = options.target ? options.target.split(",").map((t) => t.trim()) : [];
+      if (cliTargets.length > 0) {
+        config.packages = cliTargets;
+        log(`CLI targets specified: ${cliTargets.join(", ")}`, "info");
+      }
+      const engine = new VersionEngine(config, !!options.json);
+      const pkgsResult = await engine.getWorkspacePackages();
+      const resolvedCount = pkgsResult.packages.length;
+      log(`Resolved ${resolvedCount} packages from workspace`, "debug");
+      log(`Config packages: ${JSON.stringify(config.packages)}`, "debug");
+      log(`Config sync: ${config.sync}`, "debug");
+      if (config.sync) {
+        log("Using sync versioning strategy.", "info");
+        engine.setStrategy("sync");
+        await engine.run(pkgsResult);
+      } else if (resolvedCount === 1) {
+        log("Using single package versioning strategy.", "info");
+        if (cliTargets.length > 0) {
+          log("--target flag is ignored for single package strategy.", "warning");
+        }
+        engine.setStrategy("single");
+        await engine.run(pkgsResult);
+      } else if (resolvedCount === 0) {
+        throw new Error("No packages found in workspace");
+      } else {
+        log("Using async versioning strategy.", "info");
+        if (cliTargets.length > 0) {
+          log(`Targeting specific packages: ${cliTargets.join(", ")}`, "info");
+        }
+        engine.setStrategy("async");
+        await engine.run(pkgsResult, cliTargets);
+      }
+      log("Versioning process completed.", "success");
+      printJsonOutput();
+    } catch (error) {
+      const { BaseVersionError } = await import("./baseError-FARJUY5U.js");
+      if (BaseVersionError.isVersionError(error)) {
+        error.logError();
+      } else {
+        log(`Error: ${error instanceof Error ? error.message : String(error)}`, "error");
+      }
+      process.exit(1);
+    }
+  });
+}
+var isMain = (() => {
+  try {
+    return process.argv[1] ? fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url) : false;
+  } catch {
+    return false;
+  }
+})();
+function createVersionProgram() {
+  return new Command().name("releasekit-version").description("Version a package or packages based on conventional commits").version(readPackageVersion(import.meta.url)).addCommand(createVersionCommand(), { isDefault: true });
+}
+if (isMain) {
+  createVersionProgram().parse();
+}
+export {
+  createVersionCommand,
+  createVersionProgram
+};

package/dist/commandExecutor-E44ID5U4.js

@@ -0,0 +1,8 @@
+import {
+  execAsync,
+  execSync
+} from "./chunk-LMPZV35Z.js";
+export {
+  execAsync,
+  execSync
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { loadConfig } from './config.ts';
+export { calculateVersion } from './core/versionCalculator.ts';
+export { VersionEngine } from './core/versionEngine.ts';
+export { createAsyncStrategy, createSingleStrategy, createSyncStrategy } from './core/versionStrategies.ts';
+export { BaseVersionError } from './errors/baseError.ts';
+export { VersionErrorCode, createVersionError } from './errors/versionError.ts';
+export { PackageProcessor } from './package/packageProcessor.ts';
+export { Config, VersionConfigBase } from './types.ts';
+export { JsonOutputData, enableJsonOutput, flushPendingWrites, getJsonData } from './utils/jsonOutput.ts';

package/dist/index.js

@@ -0,0 +1,33 @@
+import {
+  PackageProcessor,
+  VersionEngine,
+  VersionErrorCode,
+  calculateVersion,
+  createAsyncStrategy,
+  createSingleStrategy,
+  createSyncStrategy,
+  createVersionError,
+  enableJsonOutput,
+  flushPendingWrites,
+  getJsonData,
+  loadConfig
+} from "./chunk-ZTFI7TXV.js";
+import {
+  BaseVersionError
+} from "./chunk-2MN2VLZF.js";
+import "./chunk-LMPZV35Z.js";
+export {
+  BaseVersionError,
+  PackageProcessor,
+  VersionEngine,
+  VersionErrorCode,
+  calculateVersion,
+  createAsyncStrategy,
+  createSingleStrategy,
+  createSyncStrategy,
+  createVersionError,
+  enableJsonOutput,
+  flushPendingWrites,
+  getJsonData,
+  loadConfig
+};

package/docs/versioning.md

@@ -4,7 +4,7 @@
 
 ## 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`:
+There are two primary methods the tool uses to decide the version bump (e.g., patch, minor, major), configured via the `versionStrategy` option in `releasekit.config.json`:
 
 ### 1. Conventional Commits (`versionStrategy: "conventional"`)
 
@@ -14,7 +14,7 @@ This is the default strategy. `releasekit-version` analyzes Git commit messages
 -   **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`.
+The specific preset used for analysis (e.g., "angular", "conventional") can be set using the `preset` option in `releasekit.config.json`.
 
 **Format:** `<type>(<scope>): <subject>`
 
@@ -39,9 +39,9 @@ The specific preset used for analysis (e.g., "angular", "conventional") can be s
 
 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"`.
+You define patterns in the `branchPattern` array in `releasekit.config.json`. Each pattern is a string like `"prefix:bumptype"`.
 
-**Example `version.config.json`:**
+**Example `releasekit.config.json`:**
 
 ```json
 {
@@ -156,7 +156,7 @@ Mismatches are detected in the following cases:
 - Git tag is ahead by a major or minor version (e.g., tag `2.0.0` vs package `1.0.0`)
 - Git tag is a prerelease but package.json is a stable release (e.g., tag `1.0.0-beta.1` vs package `1.0.0`)
 
-Configure it in `version.config.json`:
+Configure it in `releasekit.config.json`:
 ```json
 {
   "mismatchStrategy": "prefer-package"
@@ -277,7 +277,7 @@ This configuration will process all packages in the `@mycompany` scope except fo
 
 ### Tag Template Configuration
 
-You can customize how tags are formatted using the following configuration options in `version.config.json`:
+You can customize how tags are formatted using the following configuration options in `releasekit.config.json`:
 
 ```json
 {
@@ -430,7 +430,7 @@ For global commit messages, use templates without `${packageName}`:
 
 ## Monorepo Versioning Modes
 
-While primarily used for single packages now, `releasekit-version` retains options for monorepo workflows, controlled mainly by the `sync` flag in `version.config.json`.
+While primarily used for single packages now, `releasekit-version` retains options for monorepo workflows, controlled mainly by the `sync` flag in `releasekit.config.json`.
 
 ### Sync Mode (`sync: true`)
 
@@ -475,7 +475,7 @@ npx releasekit-version --bump minor --prerelease beta
 # Result: 1.0.0 -> 1.1.0-beta.0
 ```
 
-You can also set a default prerelease identifier in your `version.config.json`:
+You can also set a default prerelease identifier in your `releasekit.config.json`:
 
 ```json
 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@releasekit/version",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Semantic versioning based on Git history and conventional commits",
   "type": "module",
   "module": "./dist/index.js",

package/docs/CI_CD_INTEGRATION.md

@@ -1,197 +0,0 @@
-# CI/CD Integration
-
-`releasekit-version` is designed to work seamlessly in CI/CD pipelines, making it easy to automate versioning as part of your release workflow.
-
-## JSON Output Mode
-
-For programmatic consumption in CI/CD scripts, `releasekit-version` provides a structured JSON output option:
-
-```bash
-# Output results in JSON format
-npx releasekit-version --json
-
-# Combine with dry-run for planning
-npx releasekit-version --dry-run --json
-```
-
-This will suppress all normal console output and instead output a single JSON object containing:
-
-```json
-{
-  "dryRun": false,                            // Whether this was a dry run
-  "updates": [                                // Array of packages that were updated
-    {
-      "packageName": "@scope/package-a",     // Package name
-      "newVersion": "1.2.3",                 // New version number
-      "filePath": "/path/to/package.json"    // Path to the updated package.json
-    }
-  ],
-  "changelogs": [                            // Structured changelog data per package
-    {
-      "packageName": "@scope/package-a",     // Package name
-      "version": "1.2.3",                   // New version
-      "previousVersion": "v1.2.2",          // Previous tag (null if none)
-      "revisionRange": "v1.2.2..HEAD",      // Git revision range used
-      "repoUrl": "https://github.com/org/repo", // Repository URL (null if unknown)
-      "entries": [                           // Parsed changelog entries
-        { "type": "added", "description": "New feature", "scope": "core" },
-        { "type": "fixed", "description": "Bug fix" }
-      ]
-    }
-  ],
-  "commitMessage": "chore: release my-package v1.2.3", // The commit message that was used
-  "tags": [                                  // Array of tags that were created
-    "v1.2.3"                                 // or package-specific tags in targeted mode
-  ]
-}
-```
-
-### Benefits of JSON Output
-
-The structured JSON output provides several advantages for CI/CD integration:
-
-- **Reliable Parsing**: Unlike text logs that might change format or include ANSI color codes, the JSON structure remains consistent
-- **Programmatic Access**: Easily extract specific values like version numbers for subsequent steps
-- **Conditional Workflows**: Trigger different CI actions based on the presence of updates or specific version changes
-- **Audit Trail**: Store the JSON output as artifacts for version change tracking
-- **Error Handling**: Better detect and respond to versioning issues in your pipeline
-
-## Sample CI/CD Integration Patterns
-
-Here are some common ways to incorporate `releasekit-version` into your CI/CD pipeline:
-
-### GitHub Actions Workflow Example
-
-```yaml
-name: Release
-
-on:
-  push:
-    branches: [main]
-
-jobs:
-  version:
-    runs-on: ubuntu-latest
-    outputs:
-      changes_detected: ${{ steps.version.outputs.changes_detected }}
-      new_version: ${{ steps.version.outputs.new_version }}
-    
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0  # Important for git history
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: '18'
-          
-      - name: Install dependencies
-        run: npm ci
-      
-      - name: Determine version
-        id: version
-        run: |
-          # Run in JSON mode for parsing
-          VERSION_OUTPUT=$(npx releasekit-version --json)
-          echo "Version output: $VERSION_OUTPUT"
-          
-          # Use jq to parse the JSON output
-          CHANGES_DETECTED=$(echo "$VERSION_OUTPUT" | jq -r '.updates | length > 0')
-          echo "changes_detected=$CHANGES_DETECTED" >> $GITHUB_OUTPUT
-          
-          if [ "$CHANGES_DETECTED" = "true" ]; then
-            # Extract the first package's new version as representative version
-            NEW_VERSION=$(echo "$VERSION_OUTPUT" | jq -r '.updates[0].newVersion')
-            echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
-          fi
-  
-  publish:
-    needs: version
-    if: needs.version.outputs.changes_detected == 'true'
-    runs-on: ubuntu-latest
-    steps:
-      # Publishing steps using the detected version
-      - run: echo "Would publish version ${{ needs.version.outputs.new_version }}"
-```
-
-### GitLab CI Pipeline Example
-
-```yaml
-stages:
-  - version
-  - publish
-
-determine_version:
-  stage: version
-  script:
-    - npm ci
-    - |
-      VERSION_OUTPUT=$(npx releasekit-version --json)
-      echo "VERSION_OUTPUT=$VERSION_OUTPUT" >> version.env
-      
-      # Parse values for use in later stages
-      CHANGES_DETECTED=$(echo "$VERSION_OUTPUT" | jq -r '.updates | length > 0')
-      echo "CHANGES_DETECTED=$CHANGES_DETECTED" >> version.env
-      
-      if [ "$CHANGES_DETECTED" = "true" ]; then
-        NEW_VERSION=$(echo "$VERSION_OUTPUT" | jq -r '.updates[0].newVersion')
-        echo "NEW_VERSION=$NEW_VERSION" >> version.env
-      fi
-  artifacts:
-    reports:
-      dotenv: version.env
-
-publish:
-  stage: publish
-  needs: determine_version
-  script:
-    - echo "Publishing version $NEW_VERSION"
-  rules:
-    - if: $CHANGES_DETECTED == "true"
-```
-
-## Working with Tags in CI
-
-When using the targeted mode with `-t` flag, `releasekit-version` creates package-specific tags (e.g., `@scope/package-a@1.2.0`) but not a global tag. If your release process needs a global tag, you can add a step to your CI/CD pipeline:
-
-```bash
-# Create a global tag based on the representative version
-NEW_VERSION=$(echo "$VERSION_OUTPUT" | jq -r '.updates[0].newVersion')
-git tag -a "v$NEW_VERSION" -m "Release v$NEW_VERSION"
-git push origin "v$NEW_VERSION"
-```
-
-## Environment Variables
-
-`releasekit-version` respects the following environment variables:
-
-- `NO_COLOR=1`: Disables colored output in logs (automatically detected in CI environments)
-- `CI=true`: Most CI environments set this automatically, which helps the tool adjust its output behaviour
-
-## Skipping CI for Version Commits
-
-If you want to prevent additional CI runs when version commits are made, you can include CI skip flags in your commit message template in `version.config.json`:
-
-```json
-{
-  "commitMessage": "chore: release ${packageName} v${version} [skip ci]",
-  // other configuration options...
-}
-```
-
-Common CI skip patterns include:
-- `[skip ci]` or `[ci skip]` - Works in GitHub Actions, GitLab CI, CircleCI
-- `[skip-ci]` - Alternative format supported by some CI systems
-- `[no ci]` - Another variant 
-
-Each CI system might have slightly different syntax, so check your CI provider's documentation for the exact skip token to use.
-
-## Tips for Reliable CI/CD Integration
-
-1. **Always use `--json`** in CI/CD pipelines for consistent output parsing
-2. **Use the `fetch-depth: 0`** option in GitHub Actions (or equivalent in other CIs) to ensure access to the full Git history
-3. **Store the JSON output** as a build artifact for debugging and auditing
-4. **Consider dry runs** in your preview/staging branches to validate version changes before they're applied
-5. **Use `--project-dir`** when running from a different directory than your project root
-6. **Be mindful of Git credentials** - ensure your CI has proper permissions for creating commits and tags