@claude-flow/deployment 3.0.0-alpha.1

package/.agentic-flow/intelligence.json

@@ -0,0 +1,16 @@
+{
+  "patterns": {
+    "command:": {
+      "success": 0.19
+    }
+  },
+  "sequences": {},
+  "memories": [],
+  "dirPatterns": {},
+  "errorPatterns": [],
+  "metrics": {
+    "totalRoutes": 2,
+    "successfulRoutes": 2,
+    "routingHistory": []
+  }
+}

package/QUICK_START.md

@@ -0,0 +1,281 @@
+# Quick Start Guide
+
+## Installation
+
+```bash
+npm install @claude-flow/deployment
+```
+
+## Common Commands
+
+### 1. Patch Release (1.0.0 → 1.0.1)
+
+```typescript
+import { prepareRelease, publishToNpm } from '@claude-flow/deployment';
+
+await prepareRelease({ bumpType: 'patch' });
+await publishToNpm({ tag: 'latest' });
+```
+
+### 2. Minor Release (1.0.0 → 1.1.0)
+
+```typescript
+await prepareRelease({ bumpType: 'minor' });
+await publishToNpm({ tag: 'latest' });
+```
+
+### 3. Major Release (1.0.0 → 2.0.0)
+
+```typescript
+await prepareRelease({ bumpType: 'major' });
+await publishToNpm({ tag: 'latest' });
+```
+
+### 4. Alpha Release (1.0.0 → 1.0.0-alpha.1)
+
+```typescript
+await prepareRelease({ bumpType: 'prerelease', channel: 'alpha' });
+await publishToNpm({ tag: 'alpha' });
+```
+
+### 5. Dry Run (Test without changes)
+
+```typescript
+await prepareRelease({ bumpType: 'minor', dryRun: true });
+await publishToNpm({ tag: 'latest', dryRun: true });
+```
+
+### 6. Validate Package
+
+```typescript
+import { validate } from '@claude-flow/deployment';
+
+const result = await validate();
+if (!result.valid) {
+  console.error(result.errors);
+}
+```
+
+## Complete Workflow
+
+```typescript
+import { validate, prepareRelease, publishToNpm } from '@claude-flow/deployment';
+
+// 1. Validate
+const validation = await validate();
+if (!validation.valid) process.exit(1);
+
+// 2. Prepare release
+const release = await prepareRelease({
+  bumpType: 'minor',
+  generateChangelog: true,
+  createTag: true,
+  commit: true
+});
+
+// 3. Publish
+const publish = await publishToNpm({
+  tag: 'latest',
+  access: 'public'
+});
+
+console.log(`Released ${publish.packageName}@${publish.version}`);
+```
+
+## Class-Based API
+
+```typescript
+import { Validator, ReleaseManager, Publisher } from '@claude-flow/deployment';
+
+const validator = new Validator();
+const manager = new ReleaseManager();
+const publisher = new Publisher();
+
+await validator.validate();
+await manager.prepareRelease({ bumpType: 'patch' });
+await publisher.publishToNpm({ tag: 'latest' });
+```
+
+## Options Reference
+
+### ReleaseOptions
+
+```typescript
+{
+  bumpType?: 'major' | 'minor' | 'patch' | 'prerelease',
+  version?: string,              // Override version
+  channel?: 'alpha' | 'beta' | 'rc' | 'latest',
+  generateChangelog?: boolean,   // Default: true
+  createTag?: boolean,           // Default: true
+  commit?: boolean,              // Default: true
+  dryRun?: boolean,              // Default: false
+  skipValidation?: boolean,      // Default: false
+  tagPrefix?: string,            // Default: 'v'
+  changelogPath?: string         // Default: 'CHANGELOG.md'
+}
+```
+
+### PublishOptions
+
+```typescript
+{
+  tag?: string,                  // Default: 'latest'
+  access?: 'public' | 'restricted',
+  dryRun?: boolean,              // Default: false
+  registry?: string,             // Custom registry URL
+  otp?: string,                  // 2FA code
+  skipBuild?: boolean,           // Default: false
+  buildCommand?: string          // Default: 'npm run build'
+}
+```
+
+### ValidationOptions
+
+```typescript
+{
+  lint?: boolean,                // Default: true
+  test?: boolean,                // Default: true
+  build?: boolean,               // Default: true
+  checkDependencies?: boolean,   // Default: true
+  checkGitStatus?: boolean,      // Default: true
+  lintCommand?: string,          // Default: 'npm run lint'
+  testCommand?: string,          // Default: 'npm test'
+  buildCommand?: string          // Default: 'npm run build'
+}
+```
+
+## Conventional Commits
+
+Use conventional commit format for automatic changelog generation:
+
+```bash
+git commit -m "feat(api): add new endpoint"
+git commit -m "fix(auth): resolve login issue"
+git commit -m "docs(readme): update examples"
+git commit -m "chore(deps): update dependencies"
+```
+
+Breaking changes:
+```bash
+git commit -m "feat(ui): redesign layout
+
+BREAKING CHANGE: new layout requires migration"
+```
+
+## Common Patterns
+
+### Prerelease to Release
+
+```typescript
+// 1. Alpha releases
+await prepareRelease({ bumpType: 'prerelease', channel: 'alpha' });
+await publishToNpm({ tag: 'alpha' });
+
+// 2. Beta releases
+await prepareRelease({ bumpType: 'prerelease', channel: 'beta' });
+await publishToNpm({ tag: 'beta' });
+
+// 3. Release candidate
+await prepareRelease({ bumpType: 'prerelease', channel: 'rc' });
+await publishToNpm({ tag: 'rc' });
+
+// 4. Final release
+await prepareRelease({ bumpType: 'patch' });
+await publishToNpm({ tag: 'latest' });
+```
+
+### Check Before Release
+
+```typescript
+import { Publisher } from '@claude-flow/deployment';
+
+const publisher = new Publisher();
+
+// Check authentication
+const authenticated = await publisher.verifyAuth();
+if (!authenticated) {
+  console.error('Not logged in to npm');
+  process.exit(1);
+}
+
+// Check if version exists
+const exists = await publisher.checkVersionExists('my-package', '1.0.0');
+if (exists) {
+  console.error('Version already published');
+  process.exit(1);
+}
+
+// Get latest version
+const latest = await publisher.getLatestVersion('my-package');
+console.log('Latest version:', latest);
+```
+
+## Error Handling
+
+```typescript
+const result = await prepareRelease({ bumpType: 'minor' });
+
+if (result.success) {
+  console.log('Success!', result.newVersion);
+} else {
+  console.error('Failed:', result.error);
+  if (result.warnings) {
+    console.warn('Warnings:', result.warnings);
+  }
+}
+```
+
+## Examples
+
+See the `/examples` directory for complete working examples:
+
+- `basic-release.ts` - Complete release workflow
+- `prerelease-workflow.ts` - Alpha/Beta/RC workflow
+- `dry-run.ts` - Test releases safely
+
+Run examples:
+```bash
+npx tsx examples/basic-release.ts
+npx tsx examples/prerelease-workflow.ts
+npx tsx examples/dry-run.ts
+```
+
+## Tips
+
+1. Always test with `dryRun: true` first
+2. Use conventional commits for better changelogs
+3. Run validation before releasing
+4. Keep your git repo clean (no uncommitted changes)
+5. Use prerelease tags for beta testing
+6. Verify npm authentication before publishing
+
+## Troubleshooting
+
+**Problem**: "Not authenticated with npm"
+```bash
+npm login
+```
+
+**Problem**: "Uncommitted changes detected"
+```bash
+git status
+git commit -am "your message"
+```
+
+**Problem**: "Package is private"
+```json
+// Remove from package.json
+"private": true
+```
+
+**Problem**: "Version already exists"
+```typescript
+// Bump version first
+await prepareRelease({ bumpType: 'patch' });
+```
+
+## Support
+
+- [Full Documentation](./README.md)
+- [Implementation Details](./IMPLEMENTATION.md)
+- [Examples](./examples/)

package/README.md

@@ -0,0 +1,333 @@
+# @claude-flow/deployment
+
+[![npm version](https://img.shields.io/npm/v/@claude-flow/deployment.svg)](https://www.npmjs.com/package/@claude-flow/deployment)
+[![npm downloads](https://img.shields.io/npm/dm/@claude-flow/deployment.svg)](https://www.npmjs.com/package/@claude-flow/deployment)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![CI/CD](https://img.shields.io/badge/CI%2FCD-Automated-green.svg)](https://github.com/ruvnet/claude-flow)
+[![Semantic Release](https://img.shields.io/badge/Semantic-Release-brightgreen.svg)](https://semantic-release.gitbook.io/)
+
+> Release management, CI/CD, and versioning module for Claude Flow v3.
+
+## Features
+
+- **Version Bumping**: Automatic version management (major, minor, patch, prerelease)
+- **Changelog Generation**: Generate changelogs from conventional commits
+- **Git Integration**: Automatic tagging and committing
+- **NPM Publishing**: Publish packages with tag support (alpha, beta, latest)
+- **Pre-Release Validation**: Lint, test, build, and dependency checks
+- **Dry Run Mode**: Test releases without making changes
+
+## Installation
+
+```bash
+npm install @claude-flow/deployment
+```
+
+## Quick Start
+
+### Prepare a Release
+
+```typescript
+import { prepareRelease } from '@claude-flow/deployment';
+
+// Bump patch version and generate changelog
+const result = await prepareRelease({
+  bumpType: 'patch',
+  generateChangelog: true,
+  createTag: true,
+  commit: true
+});
+
+console.log(`Released ${result.newVersion}`);
+```
+
+### Publish to NPM
+
+```typescript
+import { publishToNpm } from '@claude-flow/deployment';
+
+// Publish with 'latest' tag
+const result = await publishToNpm({
+  tag: 'latest',
+  access: 'public'
+});
+
+console.log(`Published ${result.packageName}@${result.version}`);
+```
+
+### Validate Package
+
+```typescript
+import { validate } from '@claude-flow/deployment';
+
+// Run all validation checks
+const result = await validate({
+  lint: true,
+  test: true,
+  build: true,
+  checkDependencies: true
+});
+
+if (!result.valid) {
+  console.error('Validation failed:', result.errors);
+}
+```
+
+## API Reference
+
+### ReleaseManager
+
+```typescript
+import { ReleaseManager } from '@claude-flow/deployment';
+
+const manager = new ReleaseManager();
+
+// Prepare release with options
+const result = await manager.prepareRelease({
+  bumpType: 'minor',           // major | minor | patch | prerelease
+  version: '2.0.0',            // Override version
+  channel: 'beta',             // alpha | beta | rc | latest
+  generateChangelog: true,     // Generate CHANGELOG.md
+  createTag: true,             // Create git tag
+  commit: true,                // Commit changes
+  dryRun: false,               // Test without changes
+  skipValidation: false,       // Skip validation checks
+  tagPrefix: 'v',              // Tag prefix (v2.0.0)
+  changelogPath: 'CHANGELOG.md' // Changelog file path
+});
+```
+
+#### Version Bumping
+
+```typescript
+// Bump patch: 1.0.0 -> 1.0.1
+await manager.prepareRelease({ bumpType: 'patch' });
+
+// Bump minor: 1.0.0 -> 1.1.0
+await manager.prepareRelease({ bumpType: 'minor' });
+
+// Bump major: 1.0.0 -> 2.0.0
+await manager.prepareRelease({ bumpType: 'major' });
+
+// Bump prerelease: 1.0.0 -> 1.0.0-alpha.1
+await manager.prepareRelease({ bumpType: 'prerelease', channel: 'alpha' });
+
+// Increment prerelease: 1.0.0-alpha.1 -> 1.0.0-alpha.2
+await manager.prepareRelease({ bumpType: 'prerelease', channel: 'alpha' });
+```
+
+#### Changelog Generation
+
+Generates changelog from conventional commits:
+
+```bash
+# Commit format: type(scope): message
+git commit -m "feat(api): add new endpoint"
+git commit -m "fix(auth): resolve login issue"
+git commit -m "feat(ui): update design BREAKING CHANGE: new layout"
+```
+
+Generated changelog:
+```markdown
+## [2.0.0] - 2026-01-04
+
+### BREAKING CHANGES
+
+- **ui**: update design BREAKING CHANGE: new layout
+
+### Features
+
+- **api**: add new endpoint
+- **ui**: update design
+
+### Bug Fixes
+
+- **auth**: resolve login issue
+```
+
+### Publisher
+
+```typescript
+import { Publisher } from '@claude-flow/deployment';
+
+const publisher = new Publisher();
+
+// Publish to npm
+const result = await publisher.publishToNpm({
+  tag: 'latest',              // npm tag (alpha, beta, latest)
+  access: 'public',           // public | restricted
+  dryRun: false,              // Test publish without actual publish
+  registry: 'https://registry.npmjs.org/',
+  otp: '123456',              // 2FA OTP code
+  skipBuild: false,           // Skip build step
+  buildCommand: 'npm run build' // Custom build command
+});
+
+// Check if version exists
+const exists = await publisher.checkVersionExists('my-package', '1.0.0');
+
+// Get latest version
+const latest = await publisher.getLatestVersion('my-package', 'latest');
+
+// Verify npm authentication
+const authenticated = await publisher.verifyAuth();
+
+// Pack to tarball
+const tarball = await publisher.pack('./dist');
+```
+
+### Validator
+
+```typescript
+import { Validator } from '@claude-flow/deployment';
+
+const validator = new Validator();
+
+// Validate package
+const result = await validator.validate({
+  lint: true,                 // Run linter
+  test: true,                 // Run tests
+  build: true,                // Run build
+  checkDependencies: true,    // Check dependencies
+  checkGitStatus: true,       // Check uncommitted changes
+  lintCommand: 'npm run lint',
+  testCommand: 'npm test',
+  buildCommand: 'npm run build'
+});
+
+console.log('Valid:', result.valid);
+console.log('Errors:', result.errors);
+console.log('Warnings:', result.warnings);
+console.log('Checks:', result.checks);
+```
+
+## Complete Release Workflow
+
+```typescript
+import { Validator, ReleaseManager, Publisher } from '@claude-flow/deployment';
+
+async function release(version: string, tag: string) {
+  // 1. Validate package
+  console.log('Validating package...');
+  const validator = new Validator();
+  const validation = await validator.validate();
+
+  if (!validation.valid) {
+    console.error('Validation failed:', validation.errors);
+    process.exit(1);
+  }
+
+  // 2. Prepare release
+  console.log('Preparing release...');
+  const manager = new ReleaseManager();
+  const release = await manager.prepareRelease({
+    version,
+    generateChangelog: true,
+    createTag: true,
+    commit: true
+  });
+
+  if (!release.success) {
+    console.error('Release preparation failed:', release.error);
+    process.exit(1);
+  }
+
+  // 3. Publish to npm
+  console.log('Publishing to npm...');
+  const publisher = new Publisher();
+  const publish = await publisher.publishToNpm({
+    tag,
+    access: 'public'
+  });
+
+  if (!publish.success) {
+    console.error('Publish failed:', publish.error);
+    process.exit(1);
+  }
+
+  console.log(`Successfully released ${publish.packageName}@${publish.version}`);
+}
+
+// Run release
+release('2.0.0', 'latest');
+```
+
+## CLI Usage
+
+```bash
+# Prepare release
+npx @claude-flow/deployment release --version 2.0.0 --changelog --tag
+
+# Publish to npm
+npx @claude-flow/deployment publish --tag latest --access public
+
+# Validate package
+npx @claude-flow/deployment validate
+```
+
+## Dry Run Mode
+
+Test releases without making changes:
+
+```typescript
+// Test release preparation
+await prepareRelease({
+  bumpType: 'minor',
+  dryRun: true
+});
+
+// Test npm publish
+await publishToNpm({
+  tag: 'beta',
+  dryRun: true
+});
+```
+
+## Channel/Tag Strategy
+
+- **`alpha`**: Early development versions (1.0.0-alpha.1)
+- **`beta`**: Feature complete, testing (1.0.0-beta.1)
+- **`rc`**: Release candidate (1.0.0-rc.1)
+- **`latest`**: Stable production release (1.0.0)
+
+```typescript
+// Prerelease workflow
+await prepareRelease({ bumpType: 'prerelease', channel: 'alpha' }); // 1.0.0-alpha.1
+await publishToNpm({ tag: 'alpha' });
+
+await prepareRelease({ bumpType: 'prerelease', channel: 'beta' });  // 1.0.0-beta.1
+await publishToNpm({ tag: 'beta' });
+
+await prepareRelease({ bumpType: 'patch' });  // 1.0.0
+await publishToNpm({ tag: 'latest' });
+```
+
+## Environment Variables
+
+```bash
+# NPM authentication
+export NPM_TOKEN="your-token"
+
+# Custom registry
+export NPM_CONFIG_REGISTRY="https://registry.npmjs.org/"
+```
+
+## Error Handling
+
+```typescript
+try {
+  const result = await prepareRelease({ bumpType: 'minor' });
+
+  if (!result.success) {
+    console.error('Release failed:', result.error);
+    console.warn('Warnings:', result.warnings);
+  }
+} catch (error) {
+  console.error('Unexpected error:', error);
+}
+```
+
+## License
+
+MIT