@williamthorsen/release-kit 0.2.2 → 1.0.0

package/CHANGELOG.md

@@ -2,7 +2,49 @@
 
 All notable changes to this project will be documented in this file.
 
-## [release-kit-v0.2.2] - 2026-03-10
+## [release-kit-v1.0.0] - 2026-03-12
+
+### Features
+
+- #28 release-kit|feat!: Migrate to CLI-driven release preparation with auto-discovery (#31)
+
+Replaces release-kit's script-based release preparation with a self-contained CLI (`npx @williamthorsen/release-kit prepare`) that auto-discovers workspaces from `pnpm-workspace.yaml`. Adds workspace auto-discovery, TypeScript config loading via jiti, config validation, and a `component()` factory that accepts full workspace-relative paths. Refactors the type system: `WorkTypeConfig` becomes a record keyed by type name, version-bump rules move to a separate `VersionPatterns` structure, and `ComponentConfig` gains a `dir` field for canonical directory identity.
+
+### Refactoring
+
+- #28 release-kit|refactor: Adjust location of config & tags file
+
+### Tooling
+
+- #28 release-kit|tooling: Remove legacy release-kit scripts
+
+## [release-kit-v0.3.0] - 2026-03-11
+
+### Features
+
+- Release-kit|feat: Extract CLI runner into release-kit and co-locate scripts with workflow
+
+Move release script logic (arg parsing, validation, component filtering) into a reusable `runReleasePrepare` function in the release-kit package. Consuming repos now provide only their config and call `runReleasePrepare(config)`.
+
+Relocate release-prepare.ts and release.config.ts from scripts/ to .github/scripts/ so they live alongside the workflow they serve.
+
+- #20 release-kit|feat: Add release-kit init CLI command for automated repo setup (#22)
+
+Add an interactive `npx release-kit init` CLI command that checks repo eligibility, detects monorepo vs single-package layout, scaffolds workflow/scripts/config files, and updates `package.json` with release scripts.
+
+Also expand `runReleasePrepare` to polymorphically handle both `MonorepoReleaseConfig` and `ReleaseConfig`, and update the esbuild plugin to preserve shebangs during compilation.
+
+- #24 release-kit|feat: Return computed tags from release prepare and write .release-tags (#27)
+
+`releasePrepare` and `releasePrepareMono` now return `string[]` of computed tag names instead of `void`. `runReleasePrepare` writes these tags to a `.release-tags` file (one tag per line) so the CI workflow can read them instead of independently deriving tag names from `git diff`. In dry-run mode the file is not written. This makes `tagPrefix` the single source of truth for tag names, eliminating the mismatch between TypeScript-computed tags and workflow-derived tags.
+
+## [strings-v3.1.1] - 2026-03-10
+
+### Tooling
+
+- \*|tooling: Change package registry from github to npmjs
+
+## [tools-v3.0.1] - 2026-03-10
 
 ### Tooling
 

package/README.md

@@ -2,7 +2,7 @@
 
 Version-bumping and changelog-generation toolkit for release workflows.
 
-This package extracts the shared release-preparation logic from the `skypilot-site` and `devtools/afg` repositories into a reusable library. It provides functions for parsing commits, determining version bumps, updating `package.json` files, and generating changelogs with `git-cliff`.
+Provides a self-contained CLI that auto-discovers workspaces from `pnpm-workspace.yaml`, parses conventional commits, determines version bumps, updates `package.json` files, and generates changelogs with `git-cliff`.
 
 ## Installation
 
@@ -10,254 +10,195 @@ This package extracts the shared release-preparation logic from the `skypilot-si
 pnpm add -D @williamthorsen/release-kit git-cliff
 ```
 
-Since this package is published to GitHub Packages, configure your `.npmrc`:
+## Quick start
+
+```bash
+# 1. Set up release-kit in your repo (scaffolds workflow + optional config)
+npx @williamthorsen/release-kit init
 
-```ini
-@williamthorsen:registry=https://npm.pkg.github.com
+# 2. Preview what a release would do
+npx @williamthorsen/release-kit prepare --dry-run
+
+# 3. Copy cliff.toml.template to your repo root (if init didn't create one)
+cp node_modules/@williamthorsen/release-kit/cliff.toml.template cliff.toml
 ```
 
-## Quick start
+That's it for most repos. The CLI auto-discovers workspaces and applies sensible defaults. Customize only what you need via `.config/release-kit.config.ts`.
 
-1. Install `@williamthorsen/release-kit` and `git-cliff` as dev dependencies
-2. Create `scripts/release-prepare.ts` and `scripts/release.config.ts` (see examples below)
-3. Add `release:prepare` scripts to `package.json`
-4. Copy `cliff.toml.template` to your repo root as `cliff.toml`
-5. Add the GitHub Actions release workflow
+## How it works
 
-## Configuration
+1. **Workspace discovery**: reads `pnpm-workspace.yaml` and resolves its `packages` globs to find workspace directories. Each directory containing a `package.json` becomes a component. If no workspace file is found, the repo is treated as a single-package project.
+2. **Config loading**: loads `.config/release-kit.config.ts` (if present) via [jiti](https://github.com/unjs/jiti) and merges it with discovered defaults.
+3. **Commit analysis**: for each component, finds commits since the last version tag, parses them for type and scope, and determines the appropriate version bump.
+4. **Version bump + changelog**: bumps `package.json` versions and generates changelogs via `git-cliff`.
+5. **Release tags file**: writes computed tags to `/tmp/release-kit/.release-tags` for CI consumption.
 
-### Single-package repo
+## CLI reference
 
-Create `scripts/release.config.ts`:
+### `release-kit prepare`
+
+Run release preparation with automatic workspace discovery.
 
-```typescript
-import { DEFAULT_WORK_TYPES } from '@williamthorsen/release-kit';
-import type { ReleaseConfig } from '@williamthorsen/release-kit';
-
-export const config: ReleaseConfig = {
-  tagPrefix: 'v',
-  packageFiles: ['package.json'],
-  changelogPaths: ['.'],
-  workTypes: [...DEFAULT_WORK_TYPES],
-  formatCommand: 'pnpm run fmt',
-};
 ```
+Usage: release-kit prepare [options]
 
-### Monorepo
+Options:
+  --dry-run                   Preview changes without writing files
+  --bump=major|minor|patch    Override the bump type for all components
+  --only=name1,name2          Only process the named components (monorepo only)
+  --help, -h                  Show help
+```
 
-Create `scripts/release.config.ts`:
+Component names for `--only` match the package directory name (e.g., `arrays`, `release-kit`).
 
-```typescript
-import { DEFAULT_WORK_TYPES } from '@williamthorsen/release-kit';
-import type { MonorepoReleaseConfig } from '@williamthorsen/release-kit';
+**Self-hosting note**: in a repo where `release-kit` is a workspace package (e.g., this monorepo), `npx` and `pnpm exec` may not resolve the binary. Run the built entry point directly:
 
-function component(dir: string) {
-  return {
-    tagPrefix: `${dir}-v`,
-    packageFiles: [`packages/${dir}/package.json`],
-    changelogPaths: [`packages/${dir}`],
-    paths: [`packages/${dir}/**`],
-  };
-}
-
-export const config: MonorepoReleaseConfig = {
-  components: [component('my-lib'), component('my-cli')],
-  workTypes: [...DEFAULT_WORK_TYPES],
-  formatCommand: 'pnpm run fmt',
-};
+```bash
+node packages/release-kit/dist/esm/bin/release-kit.js prepare --dry-run
 ```
 
-### ReleaseConfig reference
+### `release-kit init`
+
+Initialize release-kit in the current repository. Scaffolds a GitHub Actions workflow and an optional config file.
+
+```
+Usage: release-kit init [options]
 
-| Field             | Type               | Required | Description                                                        |
-| ----------------- | ------------------ | -------- | ------------------------------------------------------------------ |
-| `tagPrefix`       | `string`           | Yes      | Git tag prefix for version tags (e.g., `'v'`)                      |
-| `packageFiles`    | `string[]`         | Yes      | Paths to `package.json` files to bump                              |
-| `changelogPaths`  | `string[]`         | Yes      | Directories in which to generate changelogs                        |
-| `workTypes`       | `WorkTypeConfig[]` | Yes      | Ordered list of work type configurations for commit categorization |
-| `formatCommand`   | `string`           | No       | Shell command to run after changelog generation                    |
-| `cliffConfigPath` | `string`           | No       | Path to `cliff.toml` (defaults to `'cliff.toml'`)                  |
+Options:
+  --dry-run     Preview changes without writing files
+  --help, -h    Show help
+```
 
-### MonorepoReleaseConfig reference
+Scaffolded files:
 
-| Field           | Type                | Required | Description                                           |
-| --------------- | ------------------- | -------- | ----------------------------------------------------- |
-| `components`    | `ComponentConfig[]` | Yes      | Per-component config (tagPrefix, packageFiles, paths) |
-| `workTypes`     | `WorkTypeConfig[]`  | Yes      | Shared work type configurations                       |
-| `formatCommand` | `string`            | No       | Shell command to run after changelog generation       |
+- `.config/release-kit.config.ts` — starter config with commented-out customization examples
+- `.github/workflows/release.yaml` — workflow that delegates to a reusable release workflow
+- `cliff.toml` — copied from the bundled template (prompted if missing)
 
-## Release script
+## Configuration
 
-Create `scripts/release-prepare.ts`:
+Configuration is optional. The CLI works out of the box by auto-discovering workspaces and applying defaults. Create `.config/release-kit.config.ts` only when you need to customize behavior.
 
-### Single-package version
+### Config file
 
 ```typescript
-import { releasePrepare } from '@williamthorsen/release-kit';
-import type { ReleaseType } from '@williamthorsen/release-kit';
-import { config } from './release.config.ts';
+import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
 
-const VALID_BUMP_TYPES: readonly string[] = ['major', 'minor', 'patch'];
-
-function parseArgs(): { dryRun: boolean; bumpOverride?: ReleaseType } {
-  const args = process.argv.slice(2);
-  let dryRun = false;
-  let bumpOverride: ReleaseType | undefined;
-
-  for (const arg of args) {
-    if (arg === '--dry-run') dryRun = true;
-    else if (arg.startsWith('--bump=')) {
-      const value = arg.slice('--bump='.length);
-      if (!VALID_BUMP_TYPES.includes(value)) {
-        console.error(`Invalid bump type "${value}". Must be: ${VALID_BUMP_TYPES.join(', ')}`);
-        process.exit(1);
-      }
-      bumpOverride = value as ReleaseType;
-    }
-  }
-
-  return { dryRun, bumpOverride };
-}
+const config: ReleaseKitConfig = {
+  // Exclude a component from release processing
+  components: [{ dir: 'internal-tools', shouldExclude: true }],
+
+  // Run a formatter after changelog generation
+  formatCommand: 'pnpm run fmt',
+
+  // Override the default version patterns
+  versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
+
+  // Add or override work types (merged with defaults by key)
+  workTypes: { perf: { header: 'Performance' } },
+};
 
-const { dryRun, bumpOverride } = parseArgs();
-releasePrepare(config, { dryRun, ...(bumpOverride ? { bumpOverride } : {}) });
+export default config;
 ```
 
-### Monorepo version
+The config file supports both `export default config` and `export const config = { ... }`.
 
-```typescript
-import { releasePrepareMono } from '@williamthorsen/release-kit';
-import type { ReleaseType } from '@williamthorsen/release-kit';
-import { config } from './release.config.ts';
+### `ReleaseKitConfig` reference
 
-const VALID_BUMP_TYPES: readonly string[] = ['major', 'minor', 'patch'];
-
-function parseArgs(): { dryRun: boolean; bumpOverride?: ReleaseType; only?: string[] } {
-  const args = process.argv.slice(2);
-  let dryRun = false;
-  let bumpOverride: ReleaseType | undefined;
-  let only: string[] | undefined;
-
-  for (const arg of args) {
-    if (arg === '--dry-run') dryRun = true;
-    else if (arg.startsWith('--bump=')) {
-      const value = arg.slice('--bump='.length);
-      if (!VALID_BUMP_TYPES.includes(value)) {
-        console.error(`Invalid bump type "${value}". Must be: ${VALID_BUMP_TYPES.join(', ')}`);
-        process.exit(1);
-      }
-      bumpOverride = value as ReleaseType;
-    } else if (arg.startsWith('--only=')) {
-      only = arg.slice('--only='.length).split(',');
-    }
-  }
-
-  return { dryRun, bumpOverride, only };
-}
+| Field              | Type                             | Description                                                  |
+| ------------------ | -------------------------------- | ------------------------------------------------------------ |
+| `cliffConfigPath`  | `string`                         | Path to `cliff.toml` (defaults to `'cliff.toml'`)            |
+| `components`       | `ComponentOverride[]`            | Override or exclude discovered components (matched by `dir`) |
+| `formatCommand`    | `string`                         | Shell command to run after changelog generation              |
+| `versionPatterns`  | `VersionPatterns`                | Rules for which commit types trigger major/minor bumps       |
+| `workspaceAliases` | `Record<string, string>`         | Maps shorthand workspace names to canonical names in commits |
+| `workTypes`        | `Record<string, WorkTypeConfig>` | Work type definitions, merged with defaults by key           |
 
-const { dryRun, bumpOverride, only } = parseArgs();
+All fields are optional.
 
-let effectiveConfig = config;
-if (only) {
-  const filtered = config.components.filter((c) => {
-    const name = c.tagPrefix.replace(/-v$/, '');
-    return only.includes(name);
-  });
-  effectiveConfig = { ...config, components: filtered };
-}
+### `ComponentOverride`
 
-releasePrepareMono(effectiveConfig, { dryRun, ...(bumpOverride ? { bumpOverride } : {}) });
+```typescript
+interface ComponentOverride {
+  dir: string; // Package directory name (e.g., 'arrays')
+  tagPrefix?: string; // Custom git tag prefix (defaults to '${dir}-v')
+  shouldExclude?: boolean; // If true, exclude from release processing
+}
 ```
 
-### package.json scripts
+### `VersionPatterns`
 
-```json
-{
-  "scripts": {
-    "release:prepare": "tsx scripts/release-prepare.ts",
-    "release:prepare:dry": "tsx scripts/release-prepare.ts --dry-run"
-  }
+Defines which commit types trigger major or minor bumps. Any recognized type not listed defaults to a patch bump.
+
+```typescript
+interface VersionPatterns {
+  major: string[]; // Patterns triggering a major bump ('!' = any breaking change)
+  minor: string[]; // Commit types triggering a minor bump
 }
 ```
 
-## GitHub Actions workflow
+Default: `{ major: ['!'], minor: ['feat', 'feature'] }`
 
-### Single-package repo
+### Default work types
 
-```yaml
-# .github/workflows/release.yaml
-name: Release
+| Key        | Header        | Aliases   |
+| ---------- | ------------- | --------- |
+| `fix`      | Bug fixes     | `bugfix`  |
+| `feat`     | Features      | `feature` |
+| `internal` | Internal      |           |
+| `refactor` | Refactoring   |           |
+| `tests`    | Tests         | `test`    |
+| `tooling`  | Tooling       |           |
+| `ci`       | CI            |           |
+| `deps`     | Dependencies  | `dep`     |
+| `docs`     | Documentation | `doc`     |
+| `fmt`      | Formatting    |           |
 
-on:
-  workflow_dispatch:
-    inputs:
-      bump:
-        description: 'Override bump type (leave empty to auto-detect)'
-        required: false
-        type: choice
-        options:
-          - ''
-          - patch
-          - minor
-          - major
+Work types from your config are merged with these defaults by key — your entries override or extend, they don't replace the full set.
 
-permissions:
-  contents: write
+## Commit format
 
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
+release-kit parses commits in these formats:
 
-      - uses: pnpm/action-setup@v4
+```
+type: description              # e.g., feat: add utility
+type(scope): description       # e.g., fix(parser): handle edge case
+workspace|type: description    # e.g., arrays|feat: add compact function
+!type: description             # breaking change (triggers major bump)
+```
 
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '24'
-          cache: 'pnpm'
+The `workspace|type:` format scopes a commit to a specific workspace in a monorepo. Use `workspaceAliases` in your config to map shorthand names to canonical workspace names.
 
-      - run: pnpm install
+## Using `component()` for manual configuration
 
-      - name: Run release preparation
-        id: prepare
-        run: |
-          ARGS=""
-          if [ -n "${{ inputs.bump }}" ]; then
-            ARGS="--bump=${{ inputs.bump }}"
-          fi
-          pnpm run release:prepare $ARGS
-          VERSION=$(node -p "require('./package.json').version")
-          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+If you need to build a `MonorepoReleaseConfig` manually (e.g., for the legacy script-based approach), the exported `component()` helper creates a `ComponentConfig` from a workspace-relative path:
 
-      - name: Check for changes
-        id: check
-        run: |
-          if git diff --quiet; then
-            echo "changed=false" >> "$GITHUB_OUTPUT"
-            echo "No release-worthy changes found."
-          else
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Commit, tag, and push
-        if: steps.check.outputs.changed == 'true'
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git add -A
-          git commit -m "release: v${{ steps.prepare.outputs.version }}"
-          git tag "v${{ steps.prepare.outputs.version }}"
-          git push origin main "v${{ steps.prepare.outputs.version }}"
+```typescript
+import { component } from '@williamthorsen/release-kit';
+
+// Accepts the full workspace-relative path
+component('packages/arrays');
+// => {
+//   dir: 'arrays',
+//   tagPrefix: 'arrays-v',
+//   packageFiles: ['packages/arrays/package.json'],
+//   changelogPaths: ['packages/arrays'],
+//   paths: ['packages/arrays/**'],
+// }
+
+// Custom tag prefix
+component('libs/core', 'core-v');
 ```
 
+The `dir` field is derived from `path.basename()`, so `packages/arrays` and `libs/arrays` both produce `dir: 'arrays'`.
+
+## GitHub Actions workflow
+
+The `init` command scaffolds a workflow that delegates to a reusable release workflow. For repos that need a self-contained workflow:
+
 ### Monorepo
 
 ```yaml
-# .github/workflows/release.yaml
 name: Release
 
 on:
@@ -293,7 +234,7 @@ jobs:
 
       - uses: actions/setup-node@v4
         with:
-          node-version: '24'
+          node-version: '22'
           cache: 'pnpm'
 
       - run: pnpm install
@@ -307,7 +248,7 @@ jobs:
           if [ -n "${{ inputs.bump }}" ]; then
             ARGS="$ARGS --bump=${{ inputs.bump }}"
           fi
-          pnpm run release:prepare $ARGS
+          npx @williamthorsen/release-kit prepare $ARGS
 
       - name: Check for changes
         id: check
@@ -319,18 +260,13 @@ jobs:
             echo "changed=true" >> "$GITHUB_OUTPUT"
           fi
 
-      - name: Determine release tags
+      - name: Read release tags
         if: steps.check.outputs.changed == 'true'
         id: tags
         run: |
-          TAGS=""
-          for pkg in $(git diff --name-only -- 'packages/*/package.json'); do
-            DIR=$(echo "$pkg" | cut -d/ -f2)
-            VERSION=$(node -p "require('./$pkg').version")
-            TAGS="$TAGS ${DIR}-v${VERSION}"
-          done
+          TAGS=$(cat /tmp/release-kit/.release-tags | tr '\n' ' ')
           echo "tags=$TAGS" >> "$GITHUB_OUTPUT"
-          echo "Releasing:$TAGS"
+          echo "Releasing: $TAGS"
 
       - name: Commit, tag, and push
         if: steps.check.outputs.changed == 'true'
@@ -345,21 +281,44 @@ jobs:
           git push origin main ${{ steps.tags.outputs.tags }}
 ```
 
+### Single-package repo
+
+The same workflow without the `only` input. Replace the prepare step with:
+
+```yaml
+- name: Run release preparation
+  run: |
+    ARGS=""
+    if [ -n "${{ inputs.bump }}" ]; then
+      ARGS="--bump=${{ inputs.bump }}"
+    fi
+    npx @williamthorsen/release-kit prepare $ARGS
+```
+
+And the tag step with:
+
+```yaml
+- name: Read release tag
+  if: steps.check.outputs.changed == 'true'
+  id: tags
+  run: |
+    TAG=$(cat /tmp/release-kit/.release-tags)
+    echo "tag=$TAG" >> "$GITHUB_OUTPUT"
+```
+
 ## Triggering a release
 
 ```sh
-# Single-package repo
-gh workflow run release.yaml
-gh workflow run release.yaml -f bump=minor
-
-# Monorepo: all components
+# All components
 gh workflow run release.yaml
 
-# Monorepo: specific component(s)
-gh workflow run release.yaml -f only=my-lib
-gh workflow run release.yaml -f only=my-lib,my-cli -f bump=minor
+# Specific component(s)
+gh workflow run release.yaml -f only=arrays
+gh workflow run release.yaml -f only=arrays,strings -f bump=minor
 ```
 
+Or use the GitHub UI: Actions > Release > Run workflow.
+
 ## cliff.toml setup
 
 The package includes a `cliff.toml.template` with a generic git-cliff configuration that:
@@ -383,13 +342,37 @@ This package shells out to two external tools:
 - **`git`** — must be available on `PATH`. Used to find tags and retrieve commit history.
 - **`git-cliff`** — must be available on `PATH`. Add `git-cliff` as a dev dependency to make it available in CI.
 
+## Legacy script-based approach
+
+The CLI-driven approach is recommended for new setups. The script-based approach (using `runReleasePrepare` with a manually maintained config) is still supported for backward compatibility.
+
+```typescript
+// .github/scripts/release.config.ts
+import type { MonorepoReleaseConfig } from '@williamthorsen/release-kit';
+import { component } from '@williamthorsen/release-kit';
+
+export const config: MonorepoReleaseConfig = {
+  components: [component('packages/arrays'), component('packages/strings')],
+  formatCommand: 'pnpm run fmt',
+};
+```
+
+```typescript
+// .github/scripts/release-prepare.ts
+import { runReleasePrepare } from '@williamthorsen/release-kit';
+import { config } from './release.config.ts';
+
+runReleasePrepare(config);
+```
+
+The key difference: the script-based approach requires manually listing every component, while the CLI auto-discovers them from `pnpm-workspace.yaml`.
+
 ## Migration from changesets
 
 1. Add `@williamthorsen/release-kit` and `git-cliff` as dev dependencies.
 2. Remove `@changesets/cli` from dev dependencies.
 3. Delete the `.changeset/` directory.
-4. Create `scripts/release-prepare.ts` and `scripts/release.config.ts` (see examples above).
-5. Replace `changeset:*` scripts in `package.json` with `release:prepare` scripts.
-6. Copy `cliff.toml.template` to your repo root as `cliff.toml`.
-7. Add the GitHub Actions release workflow.
-8. Create an initial version tag for each package (e.g., `git tag v1.0.0` or `git tag my-lib-v1.0.0`).
+4. Run `npx @williamthorsen/release-kit init` to scaffold workflow and config files.
+5. Remove `changeset:*` scripts from `package.json` (no replacement needed — the CLI handles everything).
+6. Copy `cliff.toml.template` to your repo root as `cliff.toml` (if `init` didn't create one).
+7. Create an initial version tag for each package (e.g., `git tag v1.0.0` or `git tag arrays-v1.0.0`).

package/dist/esm/.cache

@@ -1 +1 @@
-d1399daa908608c433b1235b6ea87a53fa94d624e116cc5a5aa3da8a5790358b
+f68170895c39861df163752e69beb845e3033a1334b92a564a1dc3b95ff170ca

package/dist/esm/bin/release-kit.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/esm/bin/release-kit.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { initCommand } from "../init/initCommand.js";
+import { prepareCommand } from "../prepareCommand.js";
+function showUsage() {
+  console.info(`
+Usage: release-kit <command> [options]
+
+Commands:
+  prepare       Run release preparation (auto-discovers workspaces)
+  init          Initialize release-kit in the current repository
+
+Options:
+  --dry-run     Preview changes without writing files
+  --help, -h    Show this help message
+`);
+}
+function showInitHelp() {
+  console.info(`
+Usage: release-kit init [options]
+
+Initialize release-kit in the current repository.
+Scaffolds workflow and config files.
+
+Options:
+  --dry-run     Preview changes without writing files
+  --help, -h    Show this help message
+`);
+}
+function showPrepareHelp() {
+  console.info(`
+Usage: release-kit prepare [options]
+
+Run release preparation with automatic workspace discovery.
+
+Options:
+  --dry-run             Run without modifying any files
+  --bump=major|minor|patch  Override the bump type for all components
+  --only=name1,name2    Only process the named components (comma-separated, monorepo only)
+  --help, -h            Show this help message
+`);
+}
+const args = process.argv.slice(2);
+const command = args[0];
+const flags = args.slice(1);
+if (command === "--help" || command === "-h" || command === void 0) {
+  showUsage();
+  process.exit(0);
+}
+if (command === "prepare") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showPrepareHelp();
+    process.exit(0);
+  }
+  await prepareCommand(flags);
+  process.exit(0);
+}
+if (command === "init") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showInitHelp();
+    process.exit(0);
+  }
+  const unknownFlags = flags.filter((f) => f !== "--dry-run" && f !== "--help" && f !== "-h");
+  if (unknownFlags.length > 0) {
+    console.error(`Error: Unknown option: ${unknownFlags[0]}`);
+    process.exit(1);
+  }
+  const dryRun = flags.includes("--dry-run");
+  const exitCode = await initCommand({ dryRun });
+  process.exit(exitCode);
+}
+console.error(`Error: Unknown command: ${command}`);
+showUsage();
+process.exit(1);