@auto-engineer/release-automation 0.24.0

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @auto-engineer/release-automation
+
+## 0.24.0
+
+### Minor Changes
+
+- [`9f33c48`](https://github.com/BeOnAuto/auto-engineer/commit/9f33c48a5e345b4e0735951c2b77d47d5e936d78) Thanks [@github-actions[bot]](https://github.com/github-actions%5Bbot%5D)! - - **packages/narrative**: adds id field to data
+  - **cli**: consolidate servers onto single port
+  - **pipeline**: add getHttpServer() method to PipelineServer
+  - **cli**: update package.json exports for server and add types
+  - **cli**: update Ketchup Plan and streamline startServer implementation
+
+## 0.23.0
+
+### Minor Changes
+
+- [#40](https://github.com/BeOnAuto/auto-engineer/pull/40) [`c7e4f17`](https://github.com/BeOnAuto/auto-engineer/commit/c7e4f1774937ead19fe46e9d3ca19208cbc24f16) Thanks [@SamHatoum](https://github.com/SamHatoum)! - - **global**: create @auto-engineer/release-automation package
+
+### Patch Changes
+
+- [`48a1981`](https://github.com/BeOnAuto/auto-engineer/commit/48a1981f2ea9e345a62f1cedd646016a9fb5ace0) Thanks [@SamHatoum](https://github.com/SamHatoum)! - - Consolidated CI jobs for more efficient build and release processes
+  - Fixed binary linking issue in release automation that could prevent proper package publishing
+
+- [#40](https://github.com/BeOnAuto/auto-engineer/pull/40) [`c7e4f17`](https://github.com/BeOnAuto/auto-engineer/commit/c7e4f1774937ead19fe46e9d3ca19208cbc24f16) Thanks [@SamHatoum](https://github.com/SamHatoum)! - - **global**: add explicit exit 0 to pre-push hook
+
+- [`42ad1e5`](https://github.com/BeOnAuto/auto-engineer/commit/42ad1e5bb31b89b56b920ed84a151a7c68dd2e5b) Thanks [@SamHatoum](https://github.com/SamHatoum)! - - Fixed an issue where special characters in commit messages could break Slack notifications

package/LICENSE

@@ -0,0 +1,10 @@
+Elastic License 2.0
+
+Copyright 2024 Sam Hatoum
+
+This software and associated documentation files (the "Software") are licensed under the Elastic License 2.0 (the "License"). You may not use this file except in compliance with the License.
+
+You may obtain a copy of the License at:
+https://www.elastic.co/licensing/elastic-license
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. 

package/README.md

@@ -0,0 +1,560 @@
+# @auto-engineer/release-automation
+
+Automated release management with changesets and conventional commits.
+
+## Features
+
+- ✅ **Automated changeset generation** from conventional commits
+- ✅ **AI-powered changelogs** with Claude CLI, Anthropic API, or simple fallback
+- ✅ **Git hook integration** for pre-push automation
+- ✅ **GitHub Actions support** for CI/CD workflows
+- ✅ **Configurable** via environment variables or config files
+- ✅ **OSS-friendly** with free tier AI options and simple fallback
+- ✅ **Library + CLI** - use programmatically or from command line
+
+## Installation
+
+```bash
+pnpm add -D @auto-engineer/release-automation
+```
+
+## Quick Start
+
+### CLI Usage
+
+```bash
+# Generate changeset from conventional commits
+release-automation generate
+
+# Preview without creating file
+release-automation generate --dry-run
+
+# Check if changesets exist
+release-automation check --verbose
+
+# Force simple changelog (no AI)
+release-automation generate --provider simple
+```
+
+### Library Usage
+
+```typescript
+import {
+  getCommitsSinceLastChangeset,
+  parseConventionalCommits,
+  determineBumpType,
+  generateChangelog,
+  createChangesetFile,
+  discoverPackages,
+} from '@auto-engineer/release-automation';
+
+// Get commits since last changeset
+const commitHashes = getCommitsSinceLastChangeset();
+
+// Parse conventional commits
+const commits = parseConventionalCommits(commitHashes);
+
+// Determine semver bump type
+const bumpType = determineBumpType(commits); // 'major' | 'minor' | 'patch'
+
+// Generate AI changelog
+const description = await generateChangelog(commits);
+
+// Discover packages from changeset config
+const packages = await discoverPackages();
+
+// Create changeset file
+createChangesetFile({ bumpType, commits, description }, packages);
+```
+
+## CLI Commands
+
+### `generate`
+
+Generate changeset from conventional commits.
+
+```bash
+release-automation generate [options]
+
+Options:
+  --since <ref>           Git reference to compare against
+  --provider <type>       Changelog provider (claude-cli|anthropic-api|simple|auto) (default: "auto")
+  --no-amend              Do not amend the last commit
+  --dry-run               Preview changeset without creating file
+  --config <path>         Path to release config file
+  --changeset-dir <path>  Changeset directory (default: .changeset)
+  --packages <names>      Comma-separated package names (overrides config)
+```
+
+**Exit codes:**
+- `0` - Success
+- `1` - General error
+- `10` - No changesets found (with `--require-changesets`)
+- `11` - No commits to process
+- `12` - No conventional commits found
+- `20` - Configuration error
+- `30` - Git error
+
+### `check`
+
+Check for pending changesets or commits that need changesets.
+
+```bash
+release-automation check [options]
+
+Options:
+  --since <ref>          Check commits since this reference
+  -v, --verbose          Show detailed information
+  --require-changesets   Exit with error if no changesets exist
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# Enable/disable features
+AUTO_CHANGESET_ENABLED=true|false           # Enable auto-changeset (default: true)
+AUTO_CHANGESET_AMEND=true|false             # Auto-amend commits (default: true)
+
+# Changelog generation
+AUTO_CHANGESET_PROVIDER=auto|claude-cli|anthropic-api|simple  # Provider (default: auto)
+ANTHROPIC_API_KEY=sk-ant-...                # For anthropic-api provider
+
+# Paths
+AUTO_CHANGESET_CONFIG_PATH=.changeset/config.json  # Changeset config path
+AUTO_CHANGESET_DIR=.changeset                      # Changeset directory
+
+# Package discovery
+AUTO_CHANGESET_PACKAGES=@pkg/a,@pkg/b       # Override package discovery
+```
+
+### Config File
+
+Create `.release-automation.json`:
+
+```json
+{
+  "changesetConfigPath": ".changeset/config.json",
+  "changelogProvider": "auto",
+  "autoAmend": true,
+  "changesetDir": ".changeset"
+}
+```
+
+Or add to `package.json`:
+
+```json
+{
+  "releaseAutomation": {
+    "changelogProvider": "auto",
+    "autoAmend": true
+  }
+}
+```
+
+## Changelog Providers
+
+The package tries providers in order until one succeeds:
+
+### 1. Claude CLI (Fastest)
+
+Requires `claude` in PATH.
+
+```bash
+# Check availability
+which claude
+
+# Install Claude CLI
+# See: https://docs.anthropic.com/claude/docs/claude-cli
+```
+
+### 2. Anthropic API
+
+Requires `ANTHROPIC_API_KEY` environment variable.
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+**Free tier:** $5 credit = 5000+ changeset generations (at ~$0.001 each)
+
+**Get API key:** https://console.anthropic.com
+
+### 3. Simple Fallback
+
+Always available. Formats commit messages into bullet points:
+
+- Groups by type (feat, fix, others)
+- Adds scope formatting
+- Limits to 5 items
+
+## Git Hook Integration
+
+Add to `.husky/pre-push`:
+
+```bash
+#!/bin/sh
+
+# Check if enabled
+if [ "${AUTO_CHANGESET_ENABLED:-true}" = "false" ]; then
+  echo "⏭️  Auto-changeset disabled"
+  exit 0
+fi
+
+# Generate changesets
+pnpm release-automation generate
+
+# Check exit code
+EXIT_CODE=$?
+if [ $EXIT_CODE -ne 0 ] && [ $EXIT_CODE -ne 11 ] && [ $EXIT_CODE -ne 12 ]; then
+  echo "❌ Failed to generate changeset"
+  exit $EXIT_CODE
+fi
+
+# Amend commit if configured
+if [ "${AUTO_CHANGESET_AMEND:-true}" = "true" ]; then
+  if [ -n "$(git status --porcelain .changeset/*.md 2>/dev/null)" ]; then
+    git add .changeset/*.md
+    git commit --amend --no-edit --no-verify
+    echo "✅ Changesets added to commit!"
+  fi
+fi
+```
+
+## GitHub Actions Integration
+
+```yaml
+- name: Check for changesets
+  id: check_changesets
+  run: |
+    if pnpm release-automation check --require-changesets; then
+      echo "has_changesets=true" >> $GITHUB_OUTPUT
+    else
+      EXIT_CODE=$?
+      if [ $EXIT_CODE -eq 10 ]; then
+        echo "has_changesets=false" >> $GITHUB_OUTPUT
+      else
+        exit $EXIT_CODE
+      fi
+    fi
+
+- name: Version packages
+  if: steps.check_changesets.outputs.has_changesets == 'true'
+  run: |
+    pnpm changeset version
+    git add .
+    git commit -m "chore: version packages"
+    git push
+```
+
+## Library API
+
+### Git Operations
+
+```typescript
+import {
+  getCommitsSinceLastChangeset,
+  getCommitsInRange,
+  getAllCommits,
+  getCommitsSinceLastTag,
+  getLastChangesetCommit,
+  getLastReleaseTag,
+  getCommitMessage,
+  isGitRepository,
+} from '@auto-engineer/release-automation';
+
+// Get commits since last changeset
+const commits = getCommitsSinceLastChangeset('.changeset');
+
+// Get commits in range
+const commits = getCommitsInRange('v1.0.0', 'HEAD');
+
+// Check if in git repo
+if (isGitRepository()) {
+  // ...
+}
+```
+
+### Conventional Commit Parsing
+
+```typescript
+import {
+  parseConventionalCommit,
+  parseConventionalCommits,
+  isConventionalCommit,
+  extractBreakingChange,
+} from '@auto-engineer/release-automation';
+
+// Parse single commit
+const commit = parseConventionalCommit('abc123');
+
+// Parse multiple commits
+const commits = parseConventionalCommits(['abc123', 'def456']);
+
+// Validate format
+if (isConventionalCommit('feat(cli): add feature')) {
+  // Valid
+}
+
+// Check for breaking changes
+if (extractBreakingChange('feat!: breaking change')) {
+  // Has breaking change
+}
+```
+
+### Semver Logic
+
+```typescript
+import {
+  determineBumpType,
+  hasBreakingChanges,
+  hasFeatures,
+} from '@auto-engineer/release-automation';
+
+const commits = parseConventionalCommits(hashes);
+
+// Determine bump type (major > minor > patch)
+const bumpType = determineBumpType(commits);
+
+// Check for breaking changes
+if (hasBreakingChanges(commits)) {
+  // Major version bump
+}
+
+// Check for features
+if (hasFeatures(commits)) {
+  // Minor version bump
+}
+```
+
+### Changelog Generation
+
+```typescript
+import { generateChangelog } from '@auto-engineer/release-automation';
+
+const commits = parseConventionalCommits(hashes);
+
+// Generate with auto provider selection
+const changelog = await generateChangelog(commits);
+
+// Force specific provider
+const changelog = await generateChangelog(commits, {
+  changelogProvider: 'simple',
+});
+
+// Use Anthropic API
+const changelog = await generateChangelog(commits, {
+  changelogProvider: 'anthropic-api',
+  anthropicApiKey: 'sk-ant-...',
+});
+```
+
+### Package Discovery
+
+```typescript
+import {
+  discoverPackages,
+  readChangesetConfig,
+  getFixedGroupPackages,
+} from '@auto-engineer/release-automation';
+
+// Discover from changeset config
+const packages = await discoverPackages('.changeset/config.json');
+
+// Read config
+const config = await readChangesetConfig();
+
+// Get fixed group packages
+const packages = getFixedGroupPackages(config);
+```
+
+### Changeset Writer
+
+```typescript
+import {
+  createChangesetFile,
+  generateChangesetFrontmatter,
+  generateChangesetFilename,
+} from '@auto-engineer/release-automation';
+
+// Create changeset file
+const result = createChangesetFile(
+  {
+    bumpType: 'minor',
+    commits,
+    description: 'Changelog content',
+  },
+  ['@pkg/a', '@pkg/b'],
+  '.changeset'
+);
+
+console.log(result.filename); // 'auto-a1b2c3d4.md'
+console.log(result.path);     // '/path/to/.changeset/auto-a1b2c3d4.md'
+
+// Generate frontmatter
+const frontmatter = generateChangesetFrontmatter(
+  ['@pkg/a', '@pkg/b'],
+  'minor'
+);
+```
+
+### Configuration Loading
+
+```typescript
+import { loadConfig } from '@auto-engineer/release-automation';
+
+// Load from all sources (env, file, defaults)
+const config = await loadConfig();
+
+// Override specific values
+const config = await loadConfig({
+  changelogProvider: 'simple',
+  autoAmend: false,
+});
+```
+
+## Conventional Commit Format
+
+This package follows the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+
+```
+<type>(<scope>): <subject>
+
+[optional body]
+
+[optional footer]
+```
+
+**Types:**
+- `feat` - New feature (minor bump)
+- `fix` - Bug fix (patch bump)
+- `docs` - Documentation changes
+- `style` - Code style changes (formatting, etc)
+- `refactor` - Code refactoring
+- `perf` - Performance improvements
+- `test` - Test changes
+- `build` - Build system changes
+- `ci` - CI configuration changes
+- `chore` - Other changes
+- `revert` - Revert previous commit
+
+**Breaking changes:**
+- Add `!` after type: `feat!: breaking change`
+- Add footer: `BREAKING CHANGE: description`
+
+## Examples
+
+### Example 1: Basic Usage
+
+```bash
+# Make some commits
+git commit -m "feat(cli): add new command"
+git commit -m "fix(server): resolve connection issue"
+
+# Generate changeset
+pnpm release-automation generate
+
+# Output:
+# ✅ Found 2 valid conventional commit(s)
+# 📊 Determined version bump: minor
+# ✨ Generating changelog...
+# ✅ Created changeset: auto-a1b2c3d4.md
+```
+
+### Example 2: Dry Run
+
+```bash
+pnpm release-automation generate --dry-run
+
+# Output:
+# 📋 Changeset Preview:
+# ---
+# Bump type: minor
+# Packages: @auto-engineer/cli, @auto-engineer/server
+#
+# Changelog:
+# - Added new command functionality
+# - Fixed connection stability issues
+# ---
+```
+
+### Example 3: CI/CD Check
+
+```bash
+# Check if changesets exist (for CI)
+pnpm release-automation check --require-changesets
+
+# Exit code 0 if changesets exist
+# Exit code 10 if no changesets
+```
+
+## Troubleshooting
+
+### "No conventional commits found"
+
+Ensure commits follow the format:
+
+```bash
+# ✅ Good
+git commit -m "feat(cli): add feature"
+git commit -m "fix: bug fix"
+
+# ❌ Bad
+git commit -m "added feature"
+git commit -m "WIP"
+```
+
+### "Failed to discover packages"
+
+Check that `.changeset/config.json` exists and has a `fixed` array:
+
+```json
+{
+  "fixed": [["@auto-engineer/*", "create-auto-app"]]
+}
+```
+
+### "Claude CLI not found"
+
+Install Claude CLI or set `ANTHROPIC_API_KEY`:
+
+```bash
+# Option 1: Install Claude CLI
+# See: https://docs.anthropic.com/claude/docs/claude-cli
+
+# Option 2: Use Anthropic API
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Option 3: Use simple mode
+pnpm release-automation generate --provider simple
+```
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Run tests (when implemented)
+pnpm test
+
+# Type check
+pnpm type-check
+
+# Watch mode
+pnpm test:watch
+```
+
+## License
+
+MIT
+
+## Related
+
+- [Changesets](https://github.com/changesets/changesets)
+- [Conventional Commits](https://www.conventionalcommits.org/)
+- [Anthropic API](https://docs.anthropic.com/)

package/dist/bin/release-automation.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=release-automation.d.ts.map

package/dist/bin/release-automation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-automation.d.ts","sourceRoot":"","sources":["../../bin/release-automation.ts"],"names":[],"mappings":""}

package/dist/bin/release-automation.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runCli } from '../src/cli/index.js';
+runCli(process.argv).catch((error) => {
+    console.error('Error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=release-automation.js.map

package/dist/bin/release-automation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-automation.js","sourceRoot":"","sources":["../../bin/release-automation.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACnC,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC/B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/src/cli/commands/check.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const checkCommand: Command;
+//# sourceMappingURL=check.d.ts.map

package/dist/src/cli/commands/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/check.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,eAAO,MAAM,YAAY,SA4DrB,CAAC"}

package/dist/src/cli/commands/check.js

@@ -0,0 +1,77 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { Command } from 'commander';
+import { getCommitsSinceLastChangeset, isGitRepository, loadConfig, parseConventionalCommits, } from '../../lib/index.js';
+import { EXIT_CODE, logError, logInfo, logSuccess } from '../utils/index.js';
+export const checkCommand = new Command('check')
+    .description('Check for pending changesets or commits that need changesets')
+    .option('--since <ref>', 'Check commits since this reference')
+    .option('-v, --verbose', 'Show detailed information')
+    .option('--require-changesets', 'Exit with error if no changesets exist')
+    .action(async (options) => {
+    try {
+        // Check if we're in a git repository
+        if (!isGitRepository()) {
+            logError('Not a git repository');
+            process.exit(EXIT_CODE.GIT_ERROR);
+        }
+        // Load configuration
+        const config = await loadConfig();
+        // Check for existing changesets
+        const changesetPath = join(process.cwd(), config.changesetDir);
+        const hasChangesets = checkForChangesets(changesetPath);
+        if (options.verbose) {
+            if (hasChangesets) {
+                logSuccess('Changesets exist');
+                listChangesets(changesetPath);
+            }
+            else {
+                logInfo('No changesets found');
+            }
+        }
+        // Check for commits that need changesets
+        const commitHashes = getCommitsSinceLastChangeset(config.changesetDir);
+        const commits = parseConventionalCommits(commitHashes);
+        if (options.verbose) {
+            if (commits.length > 0) {
+                logInfo(`Found ${commits.length} commit(s) that may need changesets`);
+            }
+            else {
+                logInfo('No commits need changesets');
+            }
+        }
+        // Exit based on options
+        if (options.requireChangesets) {
+            if (!hasChangesets) {
+                logError('No changesets found (use --require-changesets)');
+                process.exit(EXIT_CODE.NO_CHANGESETS);
+            }
+        }
+        if (hasChangesets) {
+            logSuccess('Changesets detected');
+        }
+        else {
+            logInfo('No changesets to process');
+        }
+        process.exit(EXIT_CODE.SUCCESS);
+    }
+    catch (error) {
+        logError(`Failed to check changesets: ${error.message}`);
+        process.exit(EXIT_CODE.ERROR);
+    }
+});
+function checkForChangesets(changesetPath) {
+    if (!existsSync(changesetPath)) {
+        return false;
+    }
+    const files = readdirSync(changesetPath).filter((f) => f.endsWith('.md') && f !== 'README.md');
+    return files.length > 0;
+}
+function listChangesets(changesetPath) {
+    const files = readdirSync(changesetPath).filter((f) => f.endsWith('.md') && f !== 'README.md');
+    console.log(`\nChangesets (${files.length}):`);
+    for (const file of files) {
+        console.log(`  - ${file}`);
+    }
+}
+//# sourceMappingURL=check.js.map