@el-j/magic-helix-core 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/default_templates/architecture/monorepo.md

@@ -1,146 +0,0 @@
-# Monorepo Development Guidelines
-
-## Overview
-This project uses a monorepo structure to manage multiple packages/applications in a single repository.
-
-## Structure
-```
-project-root/
-├── packages/
-│   ├── package-a/
-│   ├── package-b/
-│   └── shared/
-├── apps/
-│   ├── web/
-│   └── mobile/
-├── package.json (workspace root)
-└── turbo.json or nx.json
-```
-
-## Workspace Commands
-- Install all dependencies: `npm install` (at root)
-- Run script in workspace: `npm run <script> --workspace=<package-name>`
-- Run script in all workspaces: `npm run <script> --workspaces`
-- Add dependency to workspace: `npm install <pkg> --workspace=<name>`
-
-## Benefits
-- Code sharing between packages
-- Atomic changes across multiple packages
-- Unified versioning and releases
-- Shared tooling and configuration
-- Single source of truth
-
-## Package Dependencies
-- Reference workspace packages: `"package-a": "*"` or `"workspace:*"`
-- Changes in dependencies trigger downstream rebuilds
-- Use semver for external dependencies
-
-## Build Orchestration
-- Define build order based on dependencies
-- Use `turbo` or `nx` for caching and parallelization
-- Run only affected packages on changes
-
-## Common Tools
-
-### Turborepo
-```json
-{
-  "pipeline": {
-    "build": {
-      "dependsOn": ["^build"],
-      "outputs": ["dist/**"]
-    },
-    "test": {
-      "dependsOn": ["build"]
-    }
-  }
-}
-```
-
-### Nx
-```json
-{
-  "tasksRunnerOptions": {
-    "default": {
-      "runner": "@nrwl/workspace/tasks-runners/default",
-      "options": {
-        "cacheableOperations": ["build", "test"]
-      }
-    }
-  }
-}
-```
-
-## Best Practices
-- Keep packages focused and small
-- Use consistent naming conventions
-- Share common configuration files
-- Version packages independently or together
-- Document package purposes in README
-- Use path mappings for imports
-- Hoist dependencies when possible
-
-## Scripts Management
-- Define common scripts at root
-- Delegate to workspace-specific scripts
-- Use parallel execution for independent tasks
-- Run affected packages only
-
-## Testing
-- Run tests from root: `npm test --workspaces`
-- Run tests for specific package: `npm test --workspace=<name>`
-- Use shared test configuration
-- Test cross-package integration
-
-## Versioning
-- **Independent**: Each package has own version
-- **Fixed**: All packages share same version
-- Use changesets for version management
-- Document breaking changes
-
-## Publishing
-- Publish packages independently
-- Use automated versioning tools
-- Test before publishing
-- Update changelogs
-
-## TypeScript Configuration
-```json
-{
-  "references": [
-    { "path": "./packages/package-a" },
-    { "path": "./packages/package-b" }
-  ]
-}
-```
-
-## Import Paths
-- Use path aliases: `@company/package-name`
-- Configure in `tsconfig.json` paths
-- Set up module resolution
-
-## Challenges & Solutions
-- **Problem**: Dependency hell
-  - **Solution**: Use workspaces, hoist dependencies
-- **Problem**: Slow builds
-  - **Solution**: Use caching (turbo/nx), build affected only
-- **Problem**: Complex tooling
-  - **Solution**: Share configs, document setup
-
-## CI/CD
-- Build only affected packages
-- Cache build outputs
-- Run tasks in parallel
-- Use matrix builds for packages
-
-## Performance
-- Enable caching for build outputs
-- Use incremental builds
-- Parallelize independent tasks
-- Skip unchanged packages
-
-## Documentation
-- Maintain root-level README
-- Document each package purpose
-- Explain workspace structure
-- Provide contribution guidelines

package/dist/default_templates/architecture/nx.md

@@ -1,122 +0,0 @@
-# Nx Monorepo Guidelines
-
-## Overview
-This monorepo uses Nx for build orchestration, code generation, and project management.
-
-## Commands
-- Run target: `nx run <project>:<target>`
-- Run for all projects: `nx run-many --target=build --all`
-- Run affected: `nx affected --target=build`
-- Show dependency graph: `nx graph`
-- Generate code: `nx generate @nx/react:component`
-
-## Project Configuration
-```json
-{
-  "name": "my-app",
-  "targets": {
-    "build": {
-      "executor": "@nx/webpack:webpack",
-      "outputs": ["{workspaceRoot}/dist/apps/my-app"],
-      "options": {
-        "outputPath": "dist/apps/my-app"
-      }
-    }
-  }
-}
-```
-
-## Affected Commands
-- Build affected: `nx affected:build`
-- Test affected: `nx affected:test`
-- Lint affected: `nx affected:lint`
-- Based on git diff from base branch
-
-## Caching
-- Nx caches task outputs automatically
-- Cache key based on inputs
-- Restore from cache for unchanged code
-- Configure cacheable operations
-
-## Generators
-- Generate applications: `nx g @nx/react:app`
-- Generate libraries: `nx g @nx/js:lib`
-- Custom generators for consistency
-- Automated code scaffolding
-
-## Project Graph
-- Visualize dependencies: `nx graph`
-- See affected projects
-- Understand project relationships
-- Detect circular dependencies
-
-## Configuration Files
-- `nx.json`: Nx configuration
-- `workspace.json` or `project.json`: Project config
-- `.nxignore`: Files to ignore
-
-## Task Pipeline
-```json
-{
-  "targetDefaults": {
-    "build": {
-      "dependsOn": ["^build"]
-    }
-  }
-}
-```
-
-## Plugins
-- Framework-specific plugins: React, Angular, Next.js
-- Tool-specific plugins: Jest, Cypress, ESLint
-- Custom plugins for specific needs
-
-## Workspace Libraries
-- Organize code into libraries
-- Enforce module boundaries
-- Share code between apps
-- Use tags for constraints
-
-## Best Practices
-- Use affected commands in CI
-- Organize libs by scope and type
-- Set up import restrictions
-- Use generators for consistency
-- Enable computation caching
-- Configure remote caching for teams
-
-## CI/CD Integration
-```yaml
-- name: Nx Cache
-  uses: actions/cache@v4
-  with:
-    path: node_modules/.cache/nx
-    key: nx-${{ github.sha }}
-    restore-keys: nx-
-
-- name: Build affected
-  run: nx affected --target=build --base=origin/main
-```
-
-## Performance
-- Parallel execution of independent tasks
-- Computation caching
-- Remote caching with Nx Cloud
-- Affected-only builds in CI
-
-## Module Boundaries
-```json
-{
-  "@nx/enforce-module-boundaries": [
-    "error",
-    {
-      "depConstraints": [
-        {
-          "sourceTag": "scope:shared",
-          "onlyDependOnLibsWithTags": ["scope:shared"]
-        }
-      ]
-    }
-  ]
-}
-```

package/dist/default_templates/architecture/turborepo.md

@@ -1,114 +0,0 @@
-# Turborepo Guidelines
-
-## Overview
-This monorepo uses Turborepo for build orchestration and caching.
-
-## Configuration
-```json
-{
-  "$schema": "https://turbo.build/schema.json",
-  "pipeline": {
-    "build": {
-      "dependsOn": ["^build"],
-      "outputs": ["dist/**", ".next/**"]
-    },
-    "test": {
-      "dependsOn": ["build"],
-      "outputs": []
-    },
-    "lint": {
-      "outputs": []
-    },
-    "dev": {
-      "cache": false
-    }
-  }
-}
-```
-
-## Commands
-- Run task across all workspaces: `turbo run build`
-- Run task in specific workspace: `turbo run build --filter=package-name`
-- Run with no cache: `turbo run build --force`
-- Clear cache: `turbo run build --no-cache`
-- Dry run: `turbo run build --dry-run`
-
-## Pipeline Configuration
-- `dependsOn`: Task dependencies
-- `^dependsOn`: Dependencies from workspace dependencies
-- `outputs`: Files to cache
-- `cache`: Enable/disable caching
-- `inputs`: Files that affect cache validity
-
-## Caching
-- Turborepo caches task outputs
-- Cache key based on inputs (files, env vars)
-- Shared cache across team (remote caching)
-- Restore from cache for unchanged code
-
-## Filtering
-- By package: `--filter=package-name`
-- By directory: `--filter=./apps/*`
-- By dependency: `--filter=...package-name`
-- By changed files: `--filter=[HEAD^1]`
-
-## Remote Caching
-```bash
-# Enable remote cache
-turbo login
-turbo link
-
-# Or use Vercel
-vercel link
-```
-
-## Environment Variables
-- Automatically included in cache key
-- Prefix with `TURBO_` for Turbo-specific vars
-- Use `.env` files for local development
-
-## Performance
-- Tasks run in parallel when possible
-- Skips cached tasks
-- Shows cache hit ratio
-- Optimizes based on dependencies
-
-## Best Practices
-- Define clear task dependencies
-- Specify all outputs for caching
-- Use `^` for workspace dependencies
-- Enable remote caching for teams
-- Run affected tasks only in CI
-- Keep pipeline config simple
-
-## Monorepo Commands
-```json
-{
-  "scripts": {
-    "build": "turbo run build",
-    "dev": "turbo run dev --parallel",
-    "test": "turbo run test",
-    "lint": "turbo run lint"
-  }
-}
-```
-
-## CI/CD Integration
-```yaml
-# GitHub Actions
-- name: Setup Turborepo cache
-  uses: actions/cache@v4
-  with:
-    path: .turbo
-    key: turbo-${{ github.sha }}
-    restore-keys: turbo-
-
-- name: Build
-  run: turbo run build
-```
-
-## Debugging
-- Use `--dry-run` to see execution plan
-- Check `.turbo/runs/*.json` for logs
-- Enable verbose output: `--verbose`
-- View graph: `turbo run build --graph`

package/dist/default_templates/ci/github-actions.md

@@ -1,268 +0,0 @@
-# GitHub Actions CI/CD Templates
-
-## Node.js/TypeScript Pipeline
-```yaml
-name: Node.js CI/CD
-
-on:
-  push:
-    branches: [main, develop]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x]
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: 'npm'
-      - run: npm ci
-      - run: npm run build
-      - run: npm test
-      - run: npm run lint
-      - name: Upload coverage
-        uses: codecov/codecov-action@v4
-        if: matrix.node-version == '20.x'
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-
-  docker:
-    needs: test
-    runs-on: ubuntu-latest
-    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-      - name: Build and push
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          tags: user/app:latest,user/app:${{ github.sha }}
-          cache-from: type=registry,ref=user/app:buildcache
-          cache-to: type=registry,ref=user/app:buildcache,mode=max
-```
-
-## Python Pipeline
-```yaml
-name: Python CI/CD
-
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.10', '3.11', '3.12']
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install Poetry
-        uses: snok/install-poetry@v1
-        with:
-          virtualenvs-create: true
-          virtualenvs-in-project: true
-      - name: Load cached venv
-        uses: actions/cache@v4
-        with:
-          path: .venv
-          key: venv-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
-      - name: Install dependencies
-        run: poetry install --no-interaction
-      - name: Run tests
-        run: poetry run pytest --cov --cov-report=xml
-      - name: Run linters
-        run: |
-          poetry run ruff check .
-          poetry run mypy .
-```
-
-## Go Pipeline
-```yaml
-name: Go CI/CD
-
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.21'
-          cache: true
-      - name: Verify dependencies
-        run: go mod verify
-      - name: Build
-        run: go build -v ./...
-      - name: Run tests
-        run: go test -v -race -coverprofile=coverage.txt ./...
-      - name: Lint
-        uses: golangci/golangci-lint-action@v4
-        with:
-          version: latest
-```
-
-## Rust Pipeline
-```yaml
-name: Rust CI/CD
-
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
-      - name: Cache cargo registry
-        uses: actions/cache@v4
-        with:
-          path: ~/.cargo/registry
-          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache cargo index
-        uses: actions/cache@v4
-        with:
-          path: ~/.cargo/git
-          key: ${{ runner.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache target
-        uses: actions/cache@v4
-        with:
-          path: target
-          key: ${{ runner.os }}-target-${{ hashFiles('**/Cargo.lock') }}
-      - name: Check formatting
-        run: cargo fmt -- --check
-      - name: Run clippy
-        run: cargo clippy -- -D warnings
-      - name: Run tests
-        run: cargo test --verbose
-      - name: Build release
-        run: cargo build --release --verbose
-```
-
-## Java/Maven Pipeline
-```yaml
-name: Java CI/CD
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          java-version: '21'
-          distribution: 'temurin'
-          cache: 'maven'
-      - name: Build with Maven
-        run: mvn -B package --file pom.xml
-      - name: Run tests
-        run: mvn test
-      - name: Generate coverage report
-        run: mvn jacoco:report
-```
-
-## Multi-Platform Docker Build
-```yaml
-name: Docker Multi-Arch
-
-on:
-  push:
-    tags: ['v*']
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to GHCR
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ghcr.io/${{ github.repository }}
-          tags: |
-            type=ref,event=branch
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-      - name: Build and push
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-```
-
-## Security Scanning
-```yaml
-name: Security Scan
-
-on:
-  push:
-    branches: [main]
-  schedule:
-    - cron: '0 0 * * 0'  # Weekly
-
-jobs:
-  scan:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run Trivy vulnerability scanner
-        uses: aquasecurity/trivy-action@master
-        with:
-          scan-type: 'fs'
-          scan-ref: '.'
-          format: 'sarif'
-          output: 'trivy-results.sarif'
-      - name: Upload results to GitHub Security
-        uses: github/codeql-action/upload-sarif@v3
-        with:
-          sarif_file: 'trivy-results.sarif'
-```
-
-## Best Practices
-1. **Caching**: Use `actions/cache` for dependencies (npm, pip, cargo, maven)
-2. **Matrix Builds**: Test against multiple language versions
-3. **Secrets**: Store credentials in GitHub Secrets, never in code
-4. **Branch Protection**: Require CI to pass before merging
-5. **Parallel Jobs**: Use `needs` to orchestrate job dependencies
-6. **Docker Layer Caching**: Use registry cache or buildx cache backends
-7. **Security Scanning**: Integrate Trivy, Snyk, or CodeQL
-8. **Artifact Storage**: Upload test reports and binaries with `actions/upload-artifact`