pipecraft 0.0.0-releaseit

package/src/utils/versioning.ts

@@ -0,0 +1,244 @@
+import { execSync } from 'child_process'
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import { PipecraftConfig } from '../types/index.js'
+
+export class VersionManager {
+  private config: PipecraftConfig
+
+  constructor(config: PipecraftConfig) {
+    this.config = config
+  }
+
+  /**
+   * Generate release-it configuration
+   */
+  generateReleaseItConfig(): string {
+    const defaultConfig = {
+      git: {
+        requireCleanWorkingDir: false,
+        commit: false,
+        pushArgs: ["--tags"],
+        tagMatch: "v[0-9]*.[0-9]*.[0-9]*"
+      },
+      github: {
+        release: false
+      },
+      npm: {
+        ignoreVersion: true,
+        publish: false,
+        skipChecks: true
+      },
+      hooks: {
+        "after:release": "echo ${version} > .release-version"
+      },
+      plugins: {
+        "@release-it/conventional-changelog": {
+          whatBump: (commits: any[], options: any) => {
+            const defaults = {
+              test: 'ignore',
+              build: 'ignore',
+              ci: 'patch',
+              docs: 'patch',
+              chore: 'minor',
+              style: 'patch',
+              fix: 'patch',
+              perf: 'patch',
+              refactor: 'patch',
+              feat: 'minor',
+              major: 'major',
+            }
+
+            // Merge with user-defined bump rules
+            const bumpRules = { ...defaults, ...this.config.versioning?.bumpRules }
+            
+            let breakings = 0
+            let features = 0
+            let levelSet = ['major', 'minor', 'patch', 'ignore']
+            
+            // eslint-disable-next-line prefer-spread
+            let level = Math.min.apply(Math, commits.map(commit => {
+              let level = levelSet.indexOf(bumpRules[commit.type as keyof typeof bumpRules] || 'ignore')
+              level = level < 0 ? 3 : level
+              
+              if (commit.notes.length > 0) {
+                breakings += commit.notes.length
+              }
+              if (commit.type === 'feat') {
+                features += 1
+              }
+              return level
+            }))
+
+            return {
+              level: level,
+              reason: breakings === 1
+                ? `There is ${breakings} BREAKING CHANGE and ${features} features`
+                : `There are ${breakings} BREAKING CHANGES and ${features} features`
+            }
+          }
+        }
+      }
+    }
+
+    return `module.exports = ${JSON.stringify(defaultConfig, null, 2)}`
+  }
+
+  /**
+   * Generate commitlint configuration
+   */
+  generateCommitlintConfig(): string {
+    return `module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    'type-enum': [
+      2,
+      'always',
+      [
+        'feat',
+        'fix',
+        'docs',
+        'style',
+        'refactor',
+        'perf',
+        'test',
+        'build',
+        'ci',
+        'chore',
+        'revert'
+      ]
+    ],
+    'subject-case': [2, 'never', ['sentence-case', 'start-case', 'pascal-case', 'upper-case']],
+    'subject-empty': [2, 'never'],
+    'subject-full-stop': [2, 'never', '.'],
+    'type-case': [2, 'always', 'lower-case'],
+    'type-empty': [2, 'never']
+  }
+}`
+  }
+
+  /**
+   * Generate husky configuration
+   */
+  generateHuskyConfig(): string {
+    return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx commitlint --edit $1`
+  }
+
+  /**
+   * Setup version management files
+   */
+  setupVersionManagement(): void {
+    if (!this.config.versioning?.enabled) {
+      return
+    }
+
+    // Generate .release-it.cjs
+    const releaseItConfig = this.generateReleaseItConfig()
+    writeFileSync('.release-it.cjs', releaseItConfig)
+
+    // Generate commitlint.config.js
+    const commitlintConfig = this.generateCommitlintConfig()
+    writeFileSync('commitlint.config.js', commitlintConfig)
+
+    // Generate .husky/commit-msg
+    const huskyDir = '.husky'
+    if (!existsSync(huskyDir)) {
+      execSync('npx husky install', { stdio: 'inherit' })
+      // Ensure directory exists (in case husky install was mocked/failed)
+      if (!existsSync(huskyDir)) {
+        const { mkdirSync } = require('fs')
+        mkdirSync(huskyDir, { recursive: true })
+      }
+    }
+    
+    const commitMsgHook = this.generateHuskyConfig()
+    writeFileSync(join(huskyDir, 'commit-msg'), commitMsgHook)
+    execSync(`chmod +x ${join(huskyDir, 'commit-msg')}`)
+
+    // Update package.json scripts
+    this.updatePackageJsonScripts()
+  }
+
+  /**
+   * Update package.json with version management scripts
+   */
+  private updatePackageJsonScripts(): void {
+    const packageJsonPath = 'package.json'
+    if (!existsSync(packageJsonPath)) {
+      return
+    }
+
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+    
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      'release': 'release-it',
+      'release:dry': 'release-it --dry-run',
+      'version:check': 'release-it --dry-run',
+      'changelog': 'conventional-changelog -p angular -i CHANGELOG.md -s',
+      'commit': 'git add . && git commit',
+      'prepare': 'husky install'
+    }
+
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+  }
+
+  /**
+   * Check if conventional commits are being used
+   */
+  validateConventionalCommits(): boolean {
+    try {
+      const result = execSync('git log --oneline -10', { encoding: 'utf8' })
+      const commits = result.split('\n').filter(line => line.trim())
+      
+      // Check if commits follow conventional format
+      const conventionalPattern = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?: .+/
+      
+      return commits.every(commit => conventionalPattern.test(commit))
+    } catch (error) {
+      return false
+    }
+  }
+
+  /**
+   * Get current version from git tags
+   */
+  getCurrentVersion(): string {
+    try {
+      const result = execSync('git describe --tags --abbrev=0', { encoding: 'utf8' })
+      return result.trim().replace('v', '')
+    } catch (error) {
+      return '0.0.0'
+    }
+  }
+
+  /**
+   * Calculate next version based on conventional commits
+   */
+  calculateNextVersion(): { version: string, type: string } {
+    try {
+      const currentVersion = this.getCurrentVersion()
+      const result = execSync('npx release-it --dry-run --no-git.requireCleanWorkingDir', { 
+        encoding: 'utf8',
+        stdio: 'pipe'
+      })
+      
+      // Parse release-it output to get version info
+      const versionMatch = result.match(/version\s+(\d+\.\d+\.\d+)/)
+      const typeMatch = result.match(/bump\s+(\w+)/)
+      
+      return {
+        version: versionMatch ? versionMatch[1] : currentVersion,
+        type: typeMatch ? typeMatch[1] : 'patch'
+      }
+    } catch (error) {
+      return {
+        version: this.getCurrentVersion(),
+        type: 'patch'
+      }
+    }
+  }
+}

package/tests/README.md

@@ -0,0 +1,229 @@
+# Pipecraft Test Suite
+
+This directory contains a comprehensive test suite for the Pipecraft project, organized by testing type and purpose.
+
+## 📁 Test Structure
+
+```
+tests/
+├── unit/                    # Unit tests for individual components
+├── integration/             # Integration tests for component interactions
+├── e2e/                     # End-to-end tests for complete workflows
+├── github-local/            # Local GitHub Actions testing with Act
+├── github-live/             # Live GitHub Actions testing
+├── fixtures/                # Test data and configurations
+├── debugging/               # GitHub Actions debugging tools
+└── README.md               # This file
+```
+
+## 🧪 Test Categories
+
+### Unit Tests (`tests/unit/`)
+- **Purpose**: Test individual functions, classes, and modules in isolation
+- **Scope**: Single components with mocked dependencies
+- **Speed**: Fast (< 1 second per test)
+- **Examples**: Config parsing, versioning logic, template rendering
+
+### Integration Tests (`tests/integration/`)
+- **Purpose**: Test interactions between multiple components
+- **Scope**: Component integration with real dependencies
+- **Speed**: Medium (1-10 seconds per test)
+- **Examples**: CLI commands, workflow generation, configuration validation
+
+### End-to-End Tests (`tests/e2e/`)
+- **Purpose**: Test complete user workflows from start to finish
+- **Scope**: Full application flow with real file system
+- **Speed**: Slow (10+ seconds per test)
+- **Examples**: Complete workflow generation, version management, deployment
+
+### GitHub Local Testing (`tests/github-local/`)
+- **Purpose**: Test GitHub Actions workflows locally using Act
+- **Scope**: Local simulation of GitHub Actions environment
+- **Speed**: Medium (5-30 seconds per test)
+- **Examples**: Workflow execution, job dependencies, environment variables
+
+### GitHub Live Testing (`tests/github-live/`)
+- **Purpose**: Test workflows on actual GitHub Actions
+- **Scope**: Real GitHub environment with live workflows
+- **Speed**: Slow (1-10 minutes per test)
+- **Examples**: Live workflow execution, performance testing, debugging
+
+### Debugging Tools (`tests/debugging/`)
+- **Purpose**: Debug and analyze GitHub Actions failures
+- **Scope**: Workflow analysis, log parsing, failure diagnosis
+- **Speed**: Variable (depends on analysis depth)
+- **Examples**: Workflow debugging, failure analysis, iterative fixing
+
+## 🚀 Running Tests
+
+### All Tests
+```bash
+# Run all test suites
+pnpm test
+
+# Run with coverage
+pnpm test:coverage
+
+# Run in watch mode
+pnpm test:watch
+```
+
+### Specific Test Types
+```bash
+# Unit tests only
+pnpm test tests/unit/
+
+# Integration tests only
+pnpm test tests/integration/
+
+# E2E tests only
+pnpm test tests/e2e/
+
+# GitHub local tests only
+./tests/github-local/run-local-tests.sh
+
+# GitHub live tests only
+./tests/github-live/run-live-tests.sh
+
+# Debugging tools
+./tests/debugging/debug-workflows.sh -w "My Pipeline"
+```
+
+## 📋 Test Requirements
+
+### Prerequisites
+- Node.js (v18+)
+- pnpm
+- Git
+- GitHub CLI (for live testing)
+- Act (for local GitHub Actions testing)
+
+### Environment Variables
+```bash
+# For GitHub live testing
+export GITHUB_TOKEN="your_github_token"
+export GITHUB_REPOSITORY="owner/repo"
+
+# For debugging
+export GITHUB_TOKEN="your_github_token"
+export GITHUB_REPOSITORY_OWNER="owner"
+export GITHUB_REPOSITORY="repo"
+```
+
+## 🔧 Test Configuration
+
+### Vitest Configuration
+Tests use Vitest with the following configuration:
+- TypeScript support
+- ES modules
+- Coverage reporting
+- Parallel execution
+- Watch mode support
+
+### Test Data
+- **Fixtures**: `tests/fixtures/` - Static test data and configurations
+- **Mocks**: Inline mocks for external dependencies
+- **Temporary files**: Created and cleaned up automatically
+
+## 📊 Test Coverage
+
+We aim for:
+- **Unit tests**: 90%+ coverage
+- **Integration tests**: 80%+ coverage
+- **E2E tests**: Critical paths covered
+- **Act tests**: All workflow types tested
+- **Live tests**: Production-like scenarios
+
+## 🐛 Debugging Tests
+
+### Common Issues
+1. **Permission errors**: Ensure test files are executable
+2. **Environment issues**: Check required environment variables
+3. **Dependency issues**: Run `pnpm install` to update dependencies
+4. **GitHub API limits**: Use appropriate rate limiting for live tests
+
+### Debug Commands
+```bash
+# Debug specific test
+pnpm test tests/unit/config.test.ts --reporter=verbose
+
+# Debug with Node inspector
+node --inspect-brk node_modules/.bin/vitest tests/unit/config.test.ts
+
+# Debug Act tests
+./tests/act/run-act-tests.sh --verbose --debug
+
+# Debug GitHub live tests
+./tests/github-live/run-live-tests.sh --debug --workflow "My Pipeline"
+```
+
+## 📝 Writing Tests
+
+### Unit Test Example
+```typescript
+import { describe, it, expect } from 'vitest'
+import { parseConfig } from '../src/utils/config'
+
+describe('Config Parser', () => {
+  it('should parse valid configuration', () => {
+    const config = parseConfig('{"version": "1.0.0"}')
+    expect(config.version).toBe('1.0.0')
+  })
+})
+```
+
+### Integration Test Example
+```typescript
+import { describe, it, expect } from 'vitest'
+import { runCLI } from './helpers/cli'
+
+describe('CLI Integration', () => {
+  it('should generate workflows', async () => {
+    const result = await runCLI(['generate'])
+    expect(result.exitCode).toBe(0)
+  })
+})
+```
+
+### E2E Test Example
+```typescript
+import { describe, it, expect } from 'vitest'
+import { generateWorkflows } from './helpers/workflow'
+
+describe('E2E Workflow Generation', () => {
+  it('should generate complete workflow suite', async () => {
+    const result = await generateWorkflows()
+    expect(result.success).toBe(true)
+    expect(result.workflows).toHaveLength(7)
+  })
+})
+```
+
+## 🔄 Continuous Integration
+
+### GitHub Actions
+Tests run automatically on:
+- Pull requests
+- Pushes to main branch
+- Scheduled runs (nightly)
+
+### Test Matrix
+- Node.js versions: 18, 20, 22
+- Operating systems: Ubuntu, macOS, Windows
+- Test types: Unit, Integration, E2E
+
+## 📚 Additional Resources
+
+- [Vitest Documentation](https://vitest.dev/)
+- [Act Documentation](https://github.com/nektos/act)
+- [GitHub Actions Documentation](https://docs.github.com/en/actions)
+- [Testing Best Practices](./testing-best-practices.md)
+
+## 🤝 Contributing
+
+When adding new tests:
+1. Follow the existing structure and naming conventions
+2. Add appropriate test data to fixtures
+3. Update this README if adding new test categories
+4. Ensure tests are fast and reliable
+5. Add documentation for complex test scenarios