@codedrifters/configulator 0.0.0 → 0.0.1

package/README.md

@@ -1,4 +1,764 @@
 # Configulator
 
-A library of Projen components used by CodeDrifters to manage repository configuration across various projects.
+A library of [Projen](https://projen.io/) components used by CodeDrifters to manage repository configuration across various projects. Configulator extends standard Projen configurations with our preferred defaults and provides company-specific components and workflows..
 
+## Table of Contents
+
+- [Overview](#overview)
+- [What is Projen?](#what-is-projen)
+- [What is Configulator?](#what-is-configulator)
+- [Project Types](#project-types)
+  - [MonorepoProject](#monorepoproject)
+  - [TypeScriptProject](#typescriptproject)
+- [Usage Patterns](#usage-patterns)
+- [Configuration Options](#configuration-options)
+- [Turbo Repo](#turbo-repo)
+- [PNPM Workspace](#pnpm-workspace)
+- [File Management Rules](#file-management-rules)
+- [Workflow Tips](#workflow-tips)
+- [API Reference](#api-reference)
+- [Troubleshooting](#troubleshooting)
+- [Additional Resources](#additional-resources)
+
+## Overview
+
+This guide explains the core infrastructure tools used in our projects: Projen and Configulator. These tools help us maintain consistency across multiple projects and reduce repetitive setup work.
+
+## What is Projen?
+
+Projen is a project generator and configuration management tool that:
+
+- Creates standardized project structures
+- Manages configuration files programmatically
+- Handles dependency updates automatically
+- Provides consistent build workflows
+
+### Key Concepts
+
+**Components:** Individual pieces of configuration (e.g., Jest, Prettier, TypeScript). Each component configures specific files and settings. When you add or remove a component, all its associated files and configurations are automatically managed.
+
+**Project Types:** Base-level configurations for different kinds of projects (e.g., TypeScript app, monorepo, React project).
+
+**Synthesis:** The process of generating actual files from your configuration. Run `npx projen` to synthesize your project.
+
+## What is Configulator?
+
+Configulator is CodeDrifters' custom extension of Projen. It:
+
+- Extends standard Projen configurations with our preferred defaults
+- Provides company-specific components and workflows
+- Available as an npm package: `@codedrifters/configulator`
+
+### Why We Built It
+
+Instead of setting up each new project from scratch (90% identical setup repeated), Configulator lets us:
+
+- Generate consistent project structures
+- Pick and choose components we need
+- Maintain standardized tooling across all projects
+- Receive updates to common configurations automatically
+
+## Project Types
+
+Configulator provides two main project types designed for monorepo workflows:
+
+### MonorepoProject
+
+**MonorepoProject** extends Projen's `TypeScriptAppProject` and is designed specifically for monorepo root projects. It provides all the infrastructure needed to manage a monorepo with multiple sub-projects.
+
+#### When to Use It
+
+Use `MonorepoProject` for:
+- Root-level monorepo configuration
+- Managing workspace-wide settings (PNPM, Turborepo, VS Code)
+- Defining shared dependency catalogs
+- Configuring build workflows for the entire monorepo
+
+#### Key Features
+
+- **PNPM Workspace Management**: Automatically generates and manages `pnpm-workspace.yaml`
+- **Turborepo Integration**: Built-in support for Turborepo with remote caching capabilities
+- **VS Code Configuration**: Automatic VS Code settings for consistent development experience
+- **Default Catalog**: Pre-configured catalog of common dependency versions (AWS CDK, Projen, Constructs, Turbo)
+- **Build Workflow Configuration**: GitHub Actions workflows with Turborepo support
+- **TypeScript Configuration**: Pre-configured TypeScript with sensible defaults
+
+#### Basic Example
+
+```typescript
+import { MonorepoProject } from '@codedrifters/configulator';
+
+const project = new MonorepoProject({
+  name: 'my-monorepo'
+});
+
+project.synth();
+```
+
+#### Advanced Example with Remote Cache
+
+```typescript
+import { MonorepoProject } from '@codedrifters/configulator';
+
+const project = new MonorepoProject({
+  name: 'my-monorepo',
+  
+  turboOptions: {
+    remoteCacheOptions: {
+      profileName: 'profile-prod-000000000000-us-east-1',
+      oidcRole: 'arn:aws:iam::000000000000:role/TurborepoRemoteCachingRole',
+      endpointParamName: '/TURBOREPO/ENDPOINT/PARAMETER',
+      tokenParamName: '/TURBOREPO/TOKEN/PARAMETER',
+      teamName: 'prod',
+    },
+  },
+  
+  pnpmOptions: {
+    pnpmWorkspaceOptions: {
+      onlyBuiltDependencies: ['@swc/core', 'esbuild', 'unrs-resolver'],
+    },
+  },
+});
+
+project.synth();
+```
+
+#### Configuration Options
+
+The `MonorepoProject` accepts all options from `TypeScriptProjectOptions` plus:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `name` | `string` | **Required** | Project name |
+| `turbo` | `boolean` | `true` | Enable Turborepo support |
+| `turboOptions` | `TurboRepoOptions` | `undefined` | Turborepo configuration including remote cache options |
+| `pnpmOptions.version` | `string` | `VERSION.PNPM_VERSION` | PNPM version to use |
+| `pnpmOptions.pnpmWorkspaceOptions` | `PnpmWorkspaceOptions` | See below | PNPM workspace configuration |
+
+**Default Behavior:**
+- `projenrcTs: true` - Uses TypeScript for projen configuration
+- `prettier: true` - Enables Prettier formatting
+- `licensed: false` - No license by default
+- `sampleCode: false` - No sample code generated
+- `jest: false` - Jest disabled at root level
+- `release: false` - Root project is not released
+- `depsUpgrade: false` - No automatic dependency upgrades at root
+- `disableTsconfigDev: true` - No tsconfig.dev.json at root
+- `packageManager: NodePackageManager.PNPM` - PNPM is mandatory
+- `defaultReleaseBranch: "main"` - Standard branch name
+
+The root project automatically includes `@codedrifters/configulator` and `constructs` as dev dependencies.
+
+### TypeScriptProject
+
+**TypeScriptProject** extends Projen's `TypeScriptProject` with CodeDrifters defaults. It's designed for sub-projects within a monorepo or standalone TypeScript projects.
+
+#### When to Use It
+
+Use `TypeScriptProject` for:
+- Sub-projects within a monorepo (most common use case)
+- Standalone TypeScript libraries or applications
+- Packages that will be published to NPM
+- Projects that need consistent testing, linting, and build configuration
+
+#### Key Features
+
+- **Automatic PNPM Version Inheritance**: Inherits PNPM version from parent `MonorepoProject` when used as a sub-project
+- **SWC for Testing**: Uses `@swc/jest` instead of `ts-jest` for faster test execution
+- **Prettier Integration**: Automatic Prettier configuration
+- **Jest Configuration**: External Jest config file (not in package.json) with sensible defaults
+- **Automatic Turborepo Integration**: Automatically configures Turborepo tasks when parent has TurboRepo enabled
+- **Catalog Dependency Support**: Can use catalog dependencies defined in parent workspace
+- **Release Support**: Built-in support for NPM releases with continuous deployment triggers
+
+#### Basic Example
+
+```typescript
+import { MonorepoProject, TypeScriptProject } from '@codedrifters/configulator';
+
+// Root project
+const root = new MonorepoProject({
+  name: 'my-monorepo'
+});
+
+// Sub-project
+const myPackage = new TypeScriptProject({
+  name: 'my-package',
+  packageName: '@myorg/my-package',
+  outdir: 'packages/my-package',
+  parent: root,
+  description: 'My awesome package',
+  deps: ['some-dependency'],
+  devDeps: ['aws-cdk-lib@catalog:', 'constructs@catalog:'],
+});
+
+root.synth();
+```
+
+#### Example with Release Configuration
+
+```typescript
+import { MonorepoProject, TypeScriptProject } from '@codedrifters/configulator';
+
+const root = new MonorepoProject({
+  name: 'my-monorepo'
+});
+
+const constructs = new TypeScriptProject({
+  name: '@codedrifters/constructs',
+  packageName: '@codedrifters/constructs',
+  outdir: 'packages/@codedrifters/constructs',
+  description: 'Constructs frequently used in CodeDrifter projects.',
+  repository: 'https://github.com/codedrifters/packages',
+  authorName: 'CodeDrifters',
+  authorOrganization: true,
+  licensed: false,
+  parent: root,
+  
+  deps: [
+    '@aws-sdk/client-dynamodb',
+    '@types/aws-lambda',
+    'change-case@^4.0',
+    'type-fest@^4',
+  ],
+  devDeps: ['aws-cdk-lib@catalog:', 'constructs@catalog:'],
+  peerDeps: ['aws-cdk-lib@catalog:', 'constructs@catalog:'],
+  
+  release: true,
+  releaseToNpm: true,
+});
+
+root.synth();
+```
+
+#### Parent-Child Relationship
+
+When `TypeScriptProject` is created with a `parent` that is a `MonorepoProject`:
+
+1. **PNPM Version**: Automatically inherits the PNPM version from the parent
+2. **Workspace Integration**: Automatically added to the parent's PNPM workspace
+3. **Turborepo Integration**: If parent has Turborepo enabled, the sub-project automatically gets Turborepo task configuration
+4. **Catalog Dependencies**: Can reference catalog dependencies defined in the parent's workspace
+5. **Dependency Upgrade Exclusions**: Automatically excludes catalog-managed dependencies from upgrade workflows
+
+#### Configuration Options
+
+The `TypeScriptProject` accepts all options from Projen's `TypeScriptProjectOptions` with these defaults:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `name` | `string` | **Required** | Project name |
+| `packageName` | `string` | Same as `name` | NPM package name |
+| `outdir` | `string` | `"."` | Output directory (required for sub-projects) |
+| `parent` | `MonorepoProject` | `undefined` | Parent monorepo project (recommended) |
+| `defaultReleaseBranch` | `string` | `"main"` | Default release branch |
+| `packageManager` | `NodePackageManager` | `PNPM` | Package manager (always PNPM) |
+| `prettier` | `boolean` | `true` | Enable Prettier |
+| `sampleCode` | `boolean` | `false` | Generate sample code |
+| `release` | `boolean` | `false` | Enable NPM releases |
+| `licensed` | `boolean` | `false` | Include license (unless `license` option provided) |
+
+**Jest Configuration:**
+- Uses external `jest.config.json` file
+- Configured to use `@swc/jest` for faster compilation
+- Test files in `src/` directory
+- ESLint rule `import/no-extraneous-dependencies` disabled for test files
+
+**NPM Ignore:**
+- Automatically ignores `*.spec.*`, `*.test.*`, and `__fixtures__` patterns
+
+**Release Configuration:**
+- Uses continuous release trigger
+- Only releases when package directory content changes
+- Release path based on `outdir`
+
+## Usage Patterns
+
+### Monorepo Setup Pattern
+
+The most common pattern is to create a monorepo with a root project and multiple sub-projects:
+
+1. **Create the root project** using `MonorepoProject`:
+
+```typescript
+// projenrc/root-project.ts
+import { MonorepoProject } from '@codedrifters/configulator';
+
+export const configureRootProject = () => {
+  const project = new MonorepoProject({
+    name: 'my-monorepo',
+    turboOptions: {
+      remoteCacheOptions: {
+        profileName: 'my-profile',
+        oidcRole: 'arn:aws:iam::123456789012:role/TurborepoRole',
+        endpointParamName: '/TURBOREPO/ENDPOINT',
+        tokenParamName: '/TURBOREPO/TOKEN',
+        teamName: 'my-team',
+      },
+    },
+  });
+  
+  return project;
+};
+```
+
+2. **Add sub-projects** using `TypeScriptProject`:
+
+```typescript
+// projenrc/my-package.ts
+import { MonorepoProject } from '@codedrifters/configulator';
+import { TypeScriptProject } from '@codedrifters/configulator';
+
+export const configureMyPackage = (parent: MonorepoProject) => {
+  const myPackage = new TypeScriptProject({
+    name: 'my-package',
+    packageName: '@myorg/my-package',
+    outdir: 'packages/my-package',
+    description: 'My package description',
+    parent,
+    deps: ['dependency-1', 'dependency-2'],
+    devDeps: ['aws-cdk-lib@catalog:', 'constructs@catalog:'],
+  });
+  
+  return { myPackage };
+};
+```
+
+3. **Wire everything together** in your main projenrc file:
+
+```typescript
+// .projenrc.ts or projenrc/index.ts
+import { configureRootProject } from './projenrc/root-project';
+import { configureMyPackage } from './projenrc/my-package';
+
+const root = configureRootProject();
+const { myPackage } = configureMyPackage(root);
+
+root.synth();
+```
+
+### Standalone Project Pattern
+
+You can also use `TypeScriptProject` without a parent for standalone projects:
+
+```typescript
+import { TypeScriptProject } from '@codedrifters/configulator';
+
+const project = new TypeScriptProject({
+  name: 'standalone-project',
+  packageName: '@myorg/standalone-project',
+  description: 'A standalone TypeScript project',
+  deps: ['some-dependency'],
+});
+
+project.synth();
+```
+
+Note: Without a parent, the project will use the default PNPM version from Configulator's version constants.
+
+### Dependency Management
+
+#### Using Catalog Dependencies
+
+The `MonorepoProject` automatically sets up a default catalog with common dependencies:
+
+```typescript
+// Defined in MonorepoProject defaults
+defaultCatalog: {
+  'aws-cdk': VERSION.AWS_CDK_CLI_VERSION,
+  'aws-cdk-lib': VERSION.AWS_CDK_LIB_VERSION,
+  'projen': VERSION.PROJEN_VERSION,
+  'constructs': VERSION.AWS_CONSTRUCTS_VERSION,
+  'turbo': VERSION.TURBO_VERSION,
+}
+```
+
+Sub-projects can reference these using the `catalog:` protocol:
+
+```typescript
+const myPackage = new TypeScriptProject({
+  // ... other options
+  devDeps: ['aws-cdk-lib@catalog:', 'constructs@catalog:'],
+  peerDeps: ['aws-cdk-lib@catalog:', 'constructs@catalog:'],
+});
+```
+
+#### Workspace Dependencies
+
+Sub-projects can depend on other packages in the same monorepo:
+
+```typescript
+const packageB = new TypeScriptProject({
+  // ... other options
+  deps: ['@myorg/package-a@workspace:*'],
+});
+```
+
+#### Custom Catalog
+
+You can also define custom catalogs in the `MonorepoProject`:
+
+```typescript
+const root = new MonorepoProject({
+  name: 'my-monorepo',
+  pnpmOptions: {
+    pnpmWorkspaceOptions: {
+      defaultCatalog: {
+        'react': '^18.0.0',
+        'typescript': '^5.0.0',
+      },
+      namedCatalogs: {
+        frontend: {
+          'react': '^18.0.0',
+          'react-dom': '^18.0.0',
+        },
+        backend: {
+          'express': '^4.18.0',
+        },
+      },
+    },
+  },
+});
+```
+
+Then reference them in sub-projects:
+
+```typescript
+// Default catalog
+deps: ['react@catalog:react']
+
+// Named catalog
+deps: ['react@catalog:frontend/react']
+```
+
+### Turborepo Integration
+
+When you create a `MonorepoProject` with `turbo: true` (the default), Turborepo is automatically configured. Sub-projects created with `TypeScriptProject` automatically get Turborepo task configuration if their parent has Turborepo enabled.
+
+The integration includes:
+- Automatic task definitions (compile, test, package)
+- Output directory configuration (`dist/**`, `lib/**`)
+- Remote cache support (when configured)
+- Build workflow integration
+
+See the [Turbo Repo](#turbo-repo) section for more details.
+
+## Configuration Options
+
+### MonorepoProjectOptions
+
+Extends `TypeScriptProjectOptions` with:
+
+```typescript
+interface MonorepoProjectOptions {
+  name: string; // Required
+  turbo?: boolean; // Default: true
+  turboOptions?: TurboRepoOptions;
+  pnpmOptions?: {
+    version?: string;
+    pnpmWorkspaceOptions?: PnpmWorkspaceOptions;
+  };
+  // ... all TypeScriptProjectOptions
+}
+```
+
+### TypeScriptProjectOptions
+
+Extends Projen's `TypeScriptProjectOptions` with CodeDrifters defaults. See the [TypeScriptProject](#typescriptproject) section for details.
+
+### TurboRepoOptions
+
+```typescript
+interface TurboRepoOptions {
+  turboVersion?: string;
+  remoteCacheOptions?: RemoteCacheOptions;
+  extends?: Array<string>;
+  globalDependencies?: Array<string>;
+  globalEnv?: Array<string>;
+  globalPassThroughEnv?: Array<string>;
+  ui?: 'tui' | 'stream';
+  envMode?: string;
+  // ... and more
+}
+
+interface RemoteCacheOptions {
+  profileName: string;
+  oidcRole: string;
+  endpointParamName: string;
+  tokenParamName: string;
+  teamName: string;
+}
+```
+
+### PnpmWorkspaceOptions
+
+```typescript
+interface PnpmWorkspaceOptions {
+  fileName?: string; // Default: 'pnpm-workspace.yaml'
+  minimumReleaseAge?: number; // Minutes, default: ONE_DAY (1440)
+  minimumReleaseAgeExclude?: Array<string>; // Default: ['@codedrifters/*']
+  onlyBuiltDependencies?: Array<string>;
+  ignoredBuiltDependencies?: Array<string>;
+  subprojects?: Array<string>;
+  defaultCatalog?: { [key: string]: string };
+  namedCatalogs?: { [catalogName: string]: { [dependencyName: string]: string } };
+}
+```
+
+## Turbo Repo
+
+### What It Does
+
+Turbo Repo is a build system for monorepos that:
+
+- Caches build outputs intelligently
+- Only rebuilds what changed
+- Speeds up CI/CD significantly
+- Works with remote caching
+
+### How It Works
+
+**Hashing:** All input files (source code, configs) are hashed
+
+**Cache Check:** If inputs haven't changed, cached outputs are reused
+
+**Smart Rebuilds:** Only affected packages rebuild when dependencies change
+
+**Remote Cache:** Build outputs stored in S3 (not Vercel) for team sharing
+
+### Configuration
+
+Turborepo is automatically enabled in `MonorepoProject` (can be disabled with `turbo: false`). Configure it using the `turboOptions`:
+
+```typescript
+const project = new MonorepoProject({
+  name: 'my-monorepo',
+  turboOptions: {
+    remoteCacheOptions: {
+      profileName: 'my-profile',
+      oidcRole: 'arn:aws:iam::123456789012:role/TurborepoRole',
+      endpointParamName: '/TURBOREPO/ENDPOINT',
+      tokenParamName: '/TURBOREPO/TOKEN',
+      teamName: 'my-team',
+    },
+  },
+});
+```
+
+### Running Locally
+
+Before using Turbo Repo locally, you need AWS credentials:
+
+```bash
+# Run the login script (credentials last ~8 hours)
+./scripts/aws-profile-turbo-repo.sh
+```
+
+**Common Error:** If you get a "gRPC error" when running Turbo first thing in the morning, the Lambda function is cold. Just run the command again - it will work the second time.
+
+### Benefits
+
+- **Fast CI:** Builds can complete in under a minute when using cached outputs
+- **Selective Rebuilds:** Only changed code rebuilds, not the entire monorepo
+- **Local + CI Sharing:** Cache between your machine and GitHub Actions
+
+## PNPM Workspace
+
+The `MonorepoProject` automatically generates and manages `pnpm-workspace.yaml`. This file:
+
+- Lists all sub-projects in the `packages` array
+- Configures PNPM settings like `minimumReleaseAge` and `onlyBuiltDependencies`
+- Defines dependency catalogs for version management
+
+### Workspace Structure
+
+The workspace file is auto-generated and lists all sub-projects:
+
+```yaml
+packages:
+  - 'packages/package-a'
+  - 'packages/package-b'
+  - 'apps/frontend'
+```
+
+Sub-projects are automatically discovered from `project.subprojects` and any additional paths specified in `pnpmWorkspaceOptions.subprojects`.
+
+### Configuration
+
+Configure the workspace through `pnpmOptions.pnpmWorkspaceOptions`:
+
+```typescript
+const project = new MonorepoProject({
+  name: 'my-monorepo',
+  pnpmOptions: {
+    pnpmWorkspaceOptions: {
+      minimumReleaseAge: MIMIMUM_RELEASE_AGE.ONE_DAY,
+      minimumReleaseAgeExclude: ['@codedrifters/*'],
+      onlyBuiltDependencies: ['@swc/core', 'esbuild'],
+      defaultCatalog: {
+        'react': '^18.0.0',
+      },
+    },
+  },
+});
+```
+
+## File Management Rules
+
+### DO NOT Edit These Files Directly
+
+Projen manages many files automatically. Never edit these files by hand:
+
+- Configuration files (`.prettierrc`, `tsconfig.json`, etc.)
+- GitHub workflows (`.github/workflows/*`)
+- Build scripts
+- Most files listed in `.projen/files.json`
+
+### Exception: package.json
+
+`package.json` is special - Projen reads, modifies, and writes it back, preserving some manual changes. However, you should still manage dependencies through Projen config, not by editing `package.json` directly.
+
+### Adding Dependencies
+
+**WRONG:**
+```bash
+npm install some-package
+```
+
+**CORRECT:** Add dependencies in your `.projenrc.ts` configuration and run `npx projen`.
+
+```typescript
+const project = new TypeScriptProject({
+  // ... other options
+  deps: ['some-package'],
+});
+```
+
+## Workflow Tips
+
+### Before Committing
+
+Run Turbo build locally (from monorepo root) to cache everything:
+
+```bash
+# This caches outputs that GitHub Actions can reuse
+pnpm build:all
+```
+
+Then commit and push. Your GitHub build will be much faster.
+
+### Adding New Packages
+
+1. Create a new configuration file in `projenrc/` (e.g., `projenrc/new-package.ts`)
+2. Export a function that creates a `TypeScriptProject` with the parent as a parameter
+3. Import and call it in your main projenrc file
+4. Run `npx projen` to regenerate configs
+5. Commit the changes
+
+Example:
+
+```typescript
+// projenrc/new-package.ts
+import { MonorepoProject, TypeScriptProject } from '@codedrifters/configulator';
+
+export const configureNewPackage = (parent: MonorepoProject) => {
+  return new TypeScriptProject({
+    name: 'new-package',
+    packageName: '@myorg/new-package',
+    outdir: 'packages/new-package',
+    parent,
+    deps: ['dependency'],
+  });
+};
+```
+
+### Updating Configulator
+
+To receive updates from Configulator in your project:
+
+1. Update the version in your projenrc definition file
+2. Run `npx projen`
+3. Review and test changes
+4. Commit
+
+## API Reference
+
+### MonorepoProject
+
+**Constructor:**
+```typescript
+new MonorepoProject(options: MonorepoProjectOptions)
+```
+
+**Key Properties:**
+- `pnpmVersion: string` - The PNPM version used by the monorepo
+
+**Key Methods:**
+- Inherits all methods from `TypeScriptAppProject`
+
+### TypeScriptProject
+
+**Constructor:**
+```typescript
+new TypeScriptProject(options: TypeScriptProjectOptions)
+```
+
+**Key Methods:**
+- `addDeps(...deps: string[])` - Add runtime dependencies
+- `addDevDeps(...deps: string[])` - Add dev dependencies
+- `addPeerDeps(...deps: string[])` - Add peer dependencies
+- Inherits all methods from Projen's `TypeScriptProject`
+
+### PnpmWorkspace
+
+**Static Method:**
+```typescript
+PnpmWorkspace.of(project: Project): PnpmWorkspace | undefined
+```
+
+Returns the PnpmWorkspace component from a project if it exists.
+
+### TurboRepo
+
+**Static Method:**
+```typescript
+TurboRepo.of(project: Project): TurboRepo | undefined
+```
+
+Returns the TurboRepo component from a project if it exists.
+
+## Troubleshooting
+
+**"Cannot find module" errors**
+
+Run `npx projen` to regenerate configuration files.
+
+**Turbo Repo cache errors**
+
+- Ensure you've run the AWS login script
+- If it's your first run of the day, try running the command twice
+
+**Build workflow failures**
+
+Check that you haven't manually edited generated files. If you have, run `npx projen` to restore them.
+
+**Dependency conflicts**
+
+Don't mix `npm install` with Projen. Always add dependencies through configuration.
+
+**Sub-project not appearing in workspace**
+
+- Ensure the sub-project has `parent` set to the MonorepoProject
+- Ensure `outdir` is set correctly
+- Run `npx projen` to regenerate the workspace file
+
+## Additional Resources
+
+- **Projen Documentation:** https://projen.io
+- **Turbo Repo Docs:** https://turbo.build/repo/docs
+- **PNPM Workspaces:** https://pnpm.io/workspaces
+- **Code Drifters Configulator:** https://www.npmjs.com/package/@codedrifters/packages
+
+---
+
+**Remember:** The goal is consistency and automation. Let the tools manage the boilerplate so you can focus on building features.