@codedrifters/configulator 0.0.153 → 0.0.155

package/lib/index.js

@@ -175,11 +175,18 @@ var require_lib = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AGENT_MODEL: () => AGENT_MODEL,
+  AGENT_PLATFORM: () => AGENT_PLATFORM,
+  AGENT_RULE_SCOPE: () => AGENT_RULE_SCOPE,
+  AgentConfig: () => AgentConfig,
   AwsDeployWorkflow: () => AwsDeployWorkflow,
   AwsDeploymentConfig: () => AwsDeploymentConfig,
   AwsDeploymentTarget: () => AwsDeploymentTarget,
+  BUILT_IN_BUNDLES: () => BUILT_IN_BUNDLES,
+  CLAUDE_RULE_TARGET: () => CLAUDE_RULE_TARGET,
   COMPLETE_JOB_ID: () => COMPLETE_JOB_ID,
   JsiiFaker: () => JsiiFaker,
+  MCP_TRANSPORT: () => MCP_TRANSPORT,
   MERGE_METHODS: () => MERGE_METHODS,
   MIMIMUM_RELEASE_AGE: () => MIMIMUM_RELEASE_AGE,
   MonorepoProject: () => MonorepoProject,
@@ -200,14 +207,556 @@ __export(index_exports, {
   Vitest: () => Vitest,
   addApproveMergeUpgradeWorkflow: () => addApproveMergeUpgradeWorkflow,
   addBuildCompleteJob: () => addBuildCompleteJob,
-  getLatestEligibleVersion: () => getLatestEligibleVersion
+  awsCdkBundle: () => awsCdkBundle,
+  baseBundle: () => baseBundle,
+  getLatestEligibleVersion: () => getLatestEligibleVersion,
+  jestBundle: () => jestBundle,
+  pnpmBundle: () => pnpmBundle,
+  projenBundle: () => projenBundle,
+  turborepoBundle: () => turborepoBundle,
+  typescriptBundle: () => typescriptBundle,
+  vitestBundle: () => vitestBundle
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/aws/aws-deployment-config.ts
-var import_node_path = require("path");
-var import_utils = __toESM(require_lib());
+// src/agent/agent-config.ts
+var import_projen7 = require("projen");
+
+// src/agent/types.ts
+var AGENT_RULE_SCOPE = {
+  ALWAYS: "always",
+  FILE_PATTERN: "file-pattern"
+};
+var AGENT_PLATFORM = {
+  CURSOR: "cursor",
+  CLAUDE: "claude",
+  CODEX: "codex",
+  COPILOT: "copilot"
+};
+var CLAUDE_RULE_TARGET = {
+  SCOPED_FILE: "scoped-file",
+  AGENTS_MD: "agents-md",
+  CLAUDE_MD: "claude-md"
+};
+var AGENT_MODEL = {
+  INHERIT: "inherit",
+  FAST: "fast",
+  BALANCED: "balanced",
+  POWERFUL: "powerful"
+};
+var MCP_TRANSPORT = {
+  STDIO: "stdio",
+  HTTP: "http",
+  SSE: "sse"
+};
+
+// src/agent/bundles/utils.ts
+function hasComponent(project, ctor) {
+  if (project.components.some((c) => c instanceof ctor)) return true;
+  return project.subprojects.some(
+    (sub) => sub.components.some((c) => c instanceof ctor)
+  );
+}
+function hasDep(project, name) {
+  if (project.deps.all.some((d) => d.name === name)) return true;
+  return project.subprojects.some(
+    (sub) => sub.deps.all.some((d) => d.name === name)
+  );
+}
+function hasFile(project, filename) {
+  if (project.tryFindFile(filename) !== void 0) return true;
+  return project.subprojects.some(
+    (sub) => sub.tryFindFile(filename) !== void 0
+  );
+}
+
+// src/agent/bundles/aws-cdk.ts
+var awsCdkBundle = {
+  name: "aws-cdk",
+  description: "AWS CDK construct patterns, L2/L3 conventions, IAM best practices",
+  appliesWhen: (project) => hasDep(project, "aws-cdk-lib"),
+  rules: [
+    {
+      name: "aws-cdk-conventions",
+      description: "AWS CDK construct patterns and best practices",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["**/*.ts"],
+      content: [
+        "# AWS CDK Conventions",
+        "",
+        "## Construct Structure",
+        "",
+        "- All constructs extend `Construct` from `constructs`",
+        "- Use `readonly` for all props interfaces",
+        "- Include minimal JSDoc for configuration options",
+        "- Follow AWS CDK best practices for resource naming and organization",
+        "- Use proper TypeScript types from `aws-cdk-lib`",
+        "- Export constructs from `index.ts` for public API",
+        "",
+        "## CDK Construct Pattern",
+        "",
+        "```typescript",
+        "export interface MyConstructProps {",
+        "  /** Brief description. */",
+        "  readonly myProperty: string;",
+        "}",
+        "",
+        "export class MyConstruct extends Construct {",
+        "  constructor(scope: Construct, id: string, props: MyConstructProps) {",
+        "    super(scope, id);",
+        "    // Implementation",
+        "  }",
+        "}",
+        "```",
+        "",
+        "## AWS Best Practices",
+        "",
+        "- Use AWS CDK v2 (`aws-cdk-lib`)",
+        "- Follow AWS best practices for security and resource configuration",
+        "- Use proper IAM permissions (principle of least privilege)",
+        "- Include proper tags and descriptions for resources",
+        "- Use SSM parameters for cross-stack references when needed",
+        "- Do not pass values between stacks; use SSM parameters instead",
+        "",
+        "## CDK Testing",
+        "",
+        "- Mock `Code.fromAsset` in any test file that synthesizes CDK stacks",
+        "- Use static S3 values (`mock-assets-bucket`, `mock-asset-key.zip`) so snapshots are stable",
+        "- Add the mock in `beforeAll` and restore in `afterAll`",
+        "- Normalize the template before snapshotting when the stack includes asset-based Lambdas"
+      ].join("\n"),
+      tags: ["infrastructure"]
+    }
+  ]
+};
+
+// src/agent/bundles/base.ts
+var baseBundle = {
+  name: "base",
+  description: "Core rules: project overview, interaction style, and general coding conventions",
+  appliesWhen: () => true,
+  rules: [
+    {
+      name: "project-overview",
+      description: "Project context and technology stack overview",
+      scope: AGENT_RULE_SCOPE.ALWAYS,
+      content: [
+        "# Project Overview",
+        "",
+        "## Important Notes",
+        "",
+        "- **Never edit generated files** \u2014 they are marked with `// ~~ Generated by projen`",
+        "- **After modifying Projen configuration**, the user should run `npx projen` locally. The agent must not run `npx projen`, `pnpm install`, or `pnpm i`.",
+        "- **Configure dependencies through Projen** \u2014 never use `npm install`, `pnpm add`, or `yarn add`. Add them to `deps` or `devDeps` in Projen config.",
+        "- **Export from index.ts** to maintain clean public APIs"
+      ].join("\n"),
+      tags: ["project"]
+    },
+    {
+      name: "interaction-style",
+      description: "Interaction style \u2014 ask questions one at a time and wait for feedback",
+      scope: AGENT_RULE_SCOPE.ALWAYS,
+      content: [
+        "# Interaction Style Guidelines",
+        "",
+        "When responding to requests, follow these interaction principles.",
+        "",
+        "1. **Ask questions one at a time**: When clarification is needed, ask a single question and wait for the user's response before proceeding.",
+        "2. **Wait for feedback**: After asking a question, pause and wait for the user's answer before asking additional questions or making assumptions.",
+        "3. **Avoid question overload**: Do not ask multiple questions in a single response. If multiple clarifications are needed, prioritize the most important question first.",
+        "4. **Progressive clarification**: Once the user answers your first question, you may then ask the next most important question if needed.",
+        "5. **Confirm understanding**: After receiving feedback, acknowledge the user's response before proceeding with the next step or question.",
+        "6. **Be patient**: Do not rush ahead with assumptions. It is better to ask one clarifying question than to proceed with incorrect assumptions."
+      ].join("\n"),
+      tags: ["project"]
+    },
+    {
+      name: "general-conventions",
+      description: "Code formatting (Prettier/ESLint), import conventions (ES modules, import order), error handling (async/await, no floating promises)",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["**/*.ts", "**/*.tsx"],
+      content: [
+        "# General Conventions",
+        "",
+        "## Code Formatting",
+        "",
+        "- Use **Prettier** for formatting (runs automatically on save in VS Code)",
+        "- Always use curly braces for control flow, even single-line statements",
+        "- Prefer `const` over `let`; avoid `var`",
+        "- Use trailing commas in multi-line objects/arrays",
+        "",
+        "### ESLint Rules to Follow",
+        "",
+        "- `curly`: Always use curly braces (multi-line, consistent)",
+        "- `dot-notation`: Use dot notation over bracket notation",
+        "- `no-bitwise`: No bitwise operators",
+        "- `@typescript-eslint/no-shadow`: No variable shadowing",
+        "- `@typescript-eslint/member-ordering`: Follow member order",
+        "",
+        "## Import Conventions",
+        "",
+        "- **Always use ES modules** (`import`/`export`), never `require()`",
+        "- Import order:",
+        "  1. Built-in Node.js modules (e.g., `node:path`, `node:fs`)",
+        "  2. External dependencies (alphabetically sorted)",
+        "  3. Internal imports (relative paths)",
+        "- Group imports with blank lines between groups",
+        "- Alphabetize imports within each group (case-insensitive)",
+        "",
+        "## Error Handling",
+        "",
+        "- Always handle promises properly with `await`",
+        "- Use `@typescript-eslint/return-await` rule (always return await)",
+        "- Never leave floating promises (`@typescript-eslint/no-floating-promises`)",
+        "- Use proper error types and meaningful error messages",
+        "- Do not swallow errors or use empty catch blocks",
+        "- Prefer async/await over raw promises"
+      ].join("\n"),
+      tags: ["coding"]
+    },
+    {
+      name: "pull-request-conventions",
+      description: "Conventional commit PR titles, closing keywords, change summaries",
+      scope: AGENT_RULE_SCOPE.ALWAYS,
+      content: [
+        "# Pull Request Conventions",
+        "",
+        "## PR Title Prefix",
+        "",
+        "**Always** use a **conventional commit prefix** in the PR `title`. Format: `type: description` or `type(scope): description`.",
+        "",
+        "| Prefix | Use for |",
+        "|--------|---------|",
+        "| `feat:` | New features or functionality |",
+        "| `fix:` | Bug fixes |",
+        "| `docs:` | Documentation-only changes |",
+        "| `chore:` | Maintenance: deps, tooling, config |",
+        "| `refactor:` | Code restructure, no behavior change |",
+        "| `release:` | Release preparation, version bumps |",
+        "| `hotfix:` | Urgent production fixes |",
+        "",
+        "## Link to the Issue",
+        "",
+        "When the PR addresses an issue, **always** include a closing keyword in the PR body:",
+        "- `Closes #<issue>`, `Fixes #<issue>`, or `Resolves #<issue>`",
+        "",
+        "## Summary of Changes",
+        "",
+        "Every PR must include a **summary of the changes** made. Use bullet points or short paragraphs. Do not leave the description empty.",
+        "",
+        "## Commit Messages",
+        "",
+        "Use **conventional commits** for git commit messages: `type: short description`. Do not add AI co-author or attribution."
+      ].join("\n"),
+      tags: ["workflow"]
+    },
+    {
+      name: "branch-naming-conventions",
+      description: "Branch format (type/[issue-]description), create-on-GitHub-then-fetch workflow",
+      scope: AGENT_RULE_SCOPE.ALWAYS,
+      content: [
+        "# Branch Naming Conventions",
+        "",
+        "## Format",
+        "",
+        "```",
+        "<type>/[<issue>-]<description>",
+        "```",
+        "",
+        "- **type** (required): One of `feat`, `fix`, `docs`, `chore`, `refactor`, `release`, `hotfix`",
+        "- **issue** (optional): Issue number (e.g., `25`). Include when known.",
+        "- **description** (required): Short, lowercase, kebab-case summary",
+        "",
+        "## Examples",
+        "",
+        "- `feat/25-add-cursor-rules`",
+        "- `fix/23-rename-cursor-rules-mdc`",
+        "- `chore/upgrade-eslint`",
+        "- `docs/update-readme`"
+      ].join("\n"),
+      tags: ["workflow"]
+    },
+    {
+      name: "issue-conventions",
+      description: "Issue title prefixes, GitHub issue type mapping, prerequisite issues",
+      scope: AGENT_RULE_SCOPE.ALWAYS,
+      content: [
+        "# Issue Title Conventions",
+        "",
+        "## Format",
+        "",
+        "```",
+        "<type>: <description>",
+        "```",
+        "",
+        "## Types",
+        "",
+        "| Prefix | Use for |",
+        "|--------|---------|",
+        "| `epic:` | Large initiatives spanning multiple child issues |",
+        "| `feat:` | New features or functionality |",
+        "| `fix:` | Bug fixes |",
+        "| `chore:` | Maintenance: deps, tooling, config |",
+        "| `docs:` | Documentation-only work |",
+        "| `refactor:` | Code restructure, no behavior change |",
+        "| `release:` | Release preparation, version bumps |",
+        "| `hotfix:` | Urgent production fixes |",
+        "",
+        "## Prerequisite Issues",
+        "",
+        "Include any prerequisite (blocking) issues in the issue body when they exist.",
+        "Use a **Dependencies** section or `**Depends on:** #123`."
+      ].join("\n"),
+      tags: ["workflow"]
+    }
+  ]
+};
+
+// src/agent/bundles/jest.ts
+var jestBundle = {
+  name: "jest",
+  description: "Jest testing conventions and patterns",
+  appliesWhen: (project) => hasDep(project, "jest"),
+  rules: [
+    {
+      name: "jest-testing",
+      description: "Jest testing conventions and patterns",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["**/*.test.ts", "**/*.spec.ts"],
+      content: [
+        "# Jest Testing Patterns",
+        "",
+        "## Mandatory Requirements",
+        "",
+        "- **Tests MUST be created or updated whenever code functionality is added or changed**",
+        "- This applies to all code changes, including:",
+        "  - New features and functionality",
+        "  - Bug fixes",
+        "  - Refactoring that changes behavior",
+        "  - API changes",
+        "  - Configuration changes that affect functionality",
+        "- Tests should be written or updated as part of the same change that modifies the code",
+        "",
+        "## Test Structure",
+        "",
+        "- Use **Jest** with SWC for fast compilation",
+        "- Test files: `.spec.ts` or `.test.ts` (co-located with source)",
+        "- Use descriptive test names: `describe('ClassName', () => { it('should do something specific', () => {}) })`",
+        "- Prefer snapshot tests for complex object structures",
+        "- Mock external dependencies appropriately",
+        "",
+        "## Test Organization",
+        "",
+        "- Co-locate test files with source files",
+        "- Test files can use dev dependencies (ESLint rule override)",
+        "- Use `@swc/jest` for fast compilation",
+        "- Configure Jest in `jest.config.json` (not in package.json)",
+        "",
+        "## Example Test Structure",
+        "",
+        "```typescript",
+        "import { MyClass } from './my-class';",
+        "",
+        "describe('MyClass', () => {",
+        "  it('should do something specific', () => {",
+        "    // Test implementation",
+        "  });",
+        "});",
+        "```"
+      ].join("\n"),
+      tags: ["testing"]
+    }
+  ]
+};
+
+// src/pnpm/pnpm-workspace.ts
+var import_path = require("path");
 var import_projen = require("projen");
+var MIMIMUM_RELEASE_AGE = {
+  ZERO_DAYS: 0,
+  ONE_HOUR: 60,
+  SIX_HOURS: 360,
+  TWELVE_HOURS: 720,
+  ONE_DAY: 1440,
+  TWO_DAYS: 2880,
+  THREE_DAYS: 4320,
+  FOUR_DAYS: 5760,
+  FIVE_DAYS: 7200,
+  SIX_DAYS: 8640,
+  ONE_WEEK: 10080
+};
+var PnpmWorkspace = class _PnpmWorkspace extends import_projen.Component {
+  /**
+   * Get the pnpm workspace component of a project. If it does not exist,
+   * return undefined.
+   *
+   * @param project
+   * @returns
+   */
+  static of(project) {
+    const isDefined = (c) => c instanceof _PnpmWorkspace;
+    return project.root.components.find(isDefined);
+  }
+  constructor(project, options = {}) {
+    super(project);
+    project.tryFindObjectFile("package.json")?.addDeletionOverride("pnpm");
+    this.fileName = options.fileName ?? "pnpm-workspace.yaml";
+    this.minimumReleaseAge = options.minimumReleaseAge ?? MIMIMUM_RELEASE_AGE.ONE_DAY;
+    this.minimumReleaseAgeExclude = options.minimumReleaseAgeExclude ? ["@codedrifters/*", ...options.minimumReleaseAgeExclude] : ["@codedrifters/*"];
+    this.onlyBuiltDependencies = options.onlyBuiltDependencies ? options.onlyBuiltDependencies : [];
+    this.ignoredBuiltDependencies = options.ignoredBuiltDependencies ? options.ignoredBuiltDependencies : [];
+    this.subprojects = options.subprojects ?? [];
+    this.defaultCatalog = options.defaultCatalog;
+    this.namedCatalogs = options.namedCatalogs;
+    project.addPackageIgnore(this.fileName);
+    new import_projen.YamlFile(this.project, this.fileName, {
+      obj: () => {
+        const pnpmConfig = {};
+        const packages = new Array();
+        for (const subproject of project.subprojects) {
+          packages.push((0, import_path.relative)(this.project.outdir, subproject.outdir));
+        }
+        const packageSet = new Set(packages);
+        for (const subprojectPath of this.subprojects) {
+          packageSet.add(subprojectPath);
+        }
+        if (this.subprojects.length > 0) {
+          packages.length = 0;
+          packages.push(...packageSet);
+        }
+        pnpmConfig.minimumReleaseAge = this.minimumReleaseAge;
+        if (this.minimumReleaseAgeExclude.length > 0) {
+          pnpmConfig.minimumReleaseAgeExclude = this.minimumReleaseAgeExclude;
+        }
+        if (this.onlyBuiltDependencies.length > 0) {
+          pnpmConfig.onlyBuiltDependencies = this.onlyBuiltDependencies;
+        }
+        if (this.ignoredBuiltDependencies.length > 0) {
+          pnpmConfig.ignoreBuiltDependencies = this.ignoredBuiltDependencies;
+        }
+        if (this.defaultCatalog && Object.keys(this.defaultCatalog).length > 0) {
+          pnpmConfig.catalog = this.defaultCatalog;
+        }
+        if (this.namedCatalogs && Object.keys(this.namedCatalogs).length > 0) {
+          pnpmConfig.namedCatalogs = this.namedCatalogs;
+        }
+        return {
+          ...packages.length > 0 ? { packages } : {},
+          ...pnpmConfig ? { ...pnpmConfig } : {}
+        };
+      }
+    });
+  }
+};
+
+// src/agent/bundles/pnpm.ts
+var pnpmBundle = {
+  name: "pnpm",
+  description: "PNPM workspace rules and dependency management conventions",
+  appliesWhen: (project) => hasComponent(project, PnpmWorkspace),
+  rules: [
+    {
+      name: "pnpm-workspace",
+      description: "PNPM workspace and dependency management conventions",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["package.json", "pnpm-workspace.yaml", "pnpm-lock.yaml"],
+      content: [
+        "# PNPM Workspace Conventions",
+        "",
+        "## Package Management",
+        "",
+        "- Use **PNPM** for package management",
+        "- Workspace configuration in `pnpm-workspace.yaml`",
+        "- Dependencies managed through Projen, not directly in `package.json`",
+        "- **Always use workspace dependencies** (`workspace:*` or `workspace:^`) for packages within this monorepo",
+        "- Never use published NPM versions of internal packages; always reference the local workspace version",
+        "",
+        "## Dependency Management",
+        "",
+        "**DO:**",
+        "- Configure dependencies in Projen configuration files (`.projenrc.ts` or `projenrc/*.ts`)",
+        "- Add dependencies to `deps`, `devDeps`, or `peerDeps` arrays in project configuration",
+        '- Use catalog dependencies when available (e.g., `"aws-cdk-lib@catalog:"`)',
+        "- Ask the user to run `npx projen` and `pnpm install` after updating dependency configuration",
+        "",
+        "**DO NOT:**",
+        "- Run `npm install some-package`",
+        "- Run `pnpm add some-package`",
+        "- Run `yarn add some-package`",
+        "- Manually edit `package.json` dependencies",
+        "",
+        "Manual package installation creates conflicts with Projen-managed files."
+      ].join("\n"),
+      tags: ["workflow"]
+    }
+  ]
+};
+
+// src/agent/bundles/projen.ts
+var projenBundle = {
+  name: "projen",
+  description: "Projen conventions, synthesis workflow, .projenrc.ts patterns",
+  appliesWhen: (project) => hasDep(project, "projen"),
+  rules: [
+    {
+      name: "projen-conventions",
+      description: "Projen configuration patterns and best practices",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["projenrc/**/*.ts", ".projenrc.ts"],
+      content: [
+        "# Projen Conventions",
+        "",
+        "## Configuration Management",
+        "",
+        "- **Never edit generated files** (`package.json`, `tsconfig.json`, etc. marked with `// ~~ Generated by projen`)",
+        "- Edit Projen configuration in:",
+        "  - `.projenrc.ts` (root)",
+        "  - `projenrc/*.ts` (package-specific)",
+        "- After making Projen changes, ask the user to run `npx projen` locally (agent must not run it)",
+        "",
+        "## Custom Projen Components",
+        "",
+        "All custom components must extend `Component` from Projen and use a static `.of()` factory for discovery:",
+        "",
+        "```typescript",
+        "export class MyComponent extends Component {",
+        "  public static of(project: Project): MyComponent | undefined {",
+        "    const isDefined = (c: Component): c is MyComponent =>",
+        "      c instanceof MyComponent;",
+        "    return project.components.find(isDefined);",
+        "  }",
+        "",
+        "  constructor(project: Project, options: MyComponentOptions) {",
+        "    super(project);",
+        "    // Implementation",
+        "  }",
+        "}",
+        "```",
+        "",
+        "## Component Authoring",
+        "",
+        "- Export project types and utilities from `index.ts`",
+        "- Follow Projen's component lifecycle patterns",
+        "- Use `merge` from `ts-deepmerge` for deep merging configuration objects",
+        "- Components should be reusable and configurable; use TypeScript interfaces for component options",
+        "- Provide sensible defaults while allowing customization",
+        "- Document public APIs with minimal JSDoc; put extended documentation in markdown",
+        "",
+        "## Dependencies",
+        "",
+        "- Dependencies managed through Projen configuration, not directly in `package.json`",
+        '- Use catalog dependencies when available (e.g., `"projen": "catalog:"`)',
+        "- Peer dependencies for shared libraries (e.g., `constructs`, `projen`, `aws-cdk-lib`)",
+        '- Use workspace protocol for internal packages: `"@org/pkg@workspace:*"`'
+      ].join("\n"),
+      tags: ["workflow"]
+    }
+  ]
+};
+
+// src/turbo/turbo-repo.ts
+var import_lib2 = require("projen/lib");
+var import_workflows_model = require("projen/lib/github/workflows-model");
 
 // src/turbo/turbo-repo-task.ts
 var import_lib = require("projen/lib");
@@ -250,8 +799,6 @@ var TurboRepoTask = class extends import_lib.Component {
 };
 
 // src/turbo/turbo-repo.ts
-var import_lib2 = require("projen/lib");
-var import_workflows_model = require("projen/lib/github/workflows-model");
 var ROOT_TURBO_TASK_NAME = "turbo:build";
 var ROOT_CI_TASK_NAME = "build:all";
 var _TurboRepo = class _TurboRepo extends import_lib2.Component {
@@ -428,38 +975,939 @@ var _TurboRepo = class _TurboRepo extends import_lib2.Component {
           {
             [this.buildTask.name]: { ...this.buildTask.taskConfig() }
           }
-        )
+        )
+      }
+    });
+    super.preSynthesize();
+  }
+};
+_TurboRepo.buildWorkflowOptions = (remoteCacheOptions) => {
+  return {
+    env: {
+      GIT_BRANCH_NAME: "${{ github.head_ref || github.ref_name }}"
+    },
+    permissions: {
+      contents: import_workflows_model.JobPermission.WRITE,
+      idToken: import_workflows_model.JobPermission.WRITE
+    },
+    preBuildSteps: [
+      {
+        name: "AWS Creds for SSM",
+        uses: "aws-actions/configure-aws-credentials@v4",
+        with: {
+          ["role-to-assume"]: remoteCacheOptions.oidcRole,
+          ["aws-region"]: "us-east-1",
+          ["role-duration-seconds"]: "900"
+        }
+      }
+    ]
+  };
+};
+var TurboRepo = _TurboRepo;
+
+// src/agent/bundles/turborepo.ts
+var turborepoBundle = {
+  name: "turborepo",
+  description: "Turborepo workspace rules and task pipeline conventions",
+  appliesWhen: (project) => hasComponent(project, TurboRepo),
+  rules: [
+    {
+      name: "turborepo-conventions",
+      description: "Turborepo build system and task pipeline conventions",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["turbo.json", "package.json"],
+      content: [
+        "# Turborepo Conventions",
+        "",
+        "## Build System",
+        "",
+        "- **Build**: `pnpm build:all` (uses Turborepo)",
+        "- **Test**: `pnpm test` or `pnpm test:watch`",
+        "- **Lint**: `pnpm eslint`",
+        "",
+        "## Task Pipeline",
+        "",
+        "- Uses remote caching (requires AWS credentials)",
+        "- Only rebuilds changed packages",
+        "- Cache key based on file hashes and dependency graph",
+        "- Configured in `turbo.json`",
+        "",
+        "## Workspace Rules",
+        "",
+        "- Source files: `src/` directory",
+        "- Tests: Co-located with source files (`.spec.ts` or `.test.ts`)",
+        "- Exports: Use `index.ts` files for clean public APIs",
+        "- Configuration: Managed by Projen (edit `.projenrc.ts` or `projenrc/*.ts`)"
+      ].join("\n"),
+      tags: ["workflow"]
+    }
+  ]
+};
+
+// src/agent/bundles/typescript.ts
+var typescriptBundle = {
+  name: "typescript",
+  description: "TypeScript conventions, type safety, naming, JSDoc, member ordering",
+  appliesWhen: (project) => hasFile(project, "tsconfig.json"),
+  rules: [
+    {
+      name: "typescript-conventions",
+      description: "TypeScript coding conventions and style guide",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["**/*.ts", "**/*.tsx"],
+      content: [
+        "# TypeScript Conventions",
+        "",
+        "## Type Safety",
+        "",
+        "- Use **strict TypeScript** with all strict checks enabled",
+        "- Always use explicit types; avoid `any` unless absolutely necessary",
+        "- Use `readonly` for immutable properties",
+        "- Prefer interfaces over types for object shapes",
+        "- Use proper TypeScript types from libraries",
+        "",
+        "## Code Organization",
+        "",
+        "- Follow the member ordering rule:",
+        "  1. Public static fields/methods",
+        "  2. Protected static fields/methods",
+        "  3. Private static fields/methods",
+        "  4. Instance fields",
+        "  5. Constructor",
+        "  6. Methods",
+        "",
+        "## Documentation",
+        "",
+        "- **Keep JSDoc minimal** so that the code remains human-readable. Use brief summaries only.",
+        "- Use JSDoc for:",
+        "  - Public classes and interfaces (short description)",
+        "  - Public methods and properties (brief purpose; parameter and return when not obvious)",
+        "  - Configuration options (one-line description)",
+        "- **Extended documentation** belongs in **markdown** files. Link from JSDoc via `@see` or an inline link.",
+        "",
+        "## Naming Conventions",
+        "",
+        "- **Classes**: PascalCase (e.g., `TypeScriptProject`, `StaticHosting`)",
+        "- **Interfaces**: PascalCase, often with `Props` suffix for configuration (e.g., `StaticHostingProps`)",
+        "- **Functions/Methods**: camelCase (e.g., `configureProject`)",
+        "- **Constants**: UPPER_SNAKE_CASE (e.g., `VERSION`, `AWS_STAGE_TYPE`)",
+        "- **Files**: kebab-case for multi-word files (e.g., `aws-deployment-config.ts`)",
+        "- **Private members**: No prefix needed (TypeScript handles visibility)"
+      ].join("\n"),
+      tags: ["coding"]
+    }
+  ]
+};
+
+// src/vitest/vitest-component.ts
+var import_projen2 = require("projen");
+var import_javascript = require("projen/lib/javascript");
+var import_textfile = require("projen/lib/textfile");
+
+// src/versions.ts
+var VERSION = {
+  /**
+   * CDK CLI for workflows and command line operations.
+   *
+   * CLI and lib are versioned separately, so this is the CLI version.
+   */
+  AWS_CDK_CLI_VERSION: "2.1117.0",
+  /**
+   * CDK Version to use for construct projects.
+   *
+   * CLI and lib are versioned separately, so this is the lib version.
+   */
+  AWS_CDK_LIB_VERSION: "2.248.0",
+  /**
+   * Version of the AWS Constructs library to use.
+   */
+  AWS_CONSTRUCTS_VERSION: "10.6.0",
+  /**
+   * Version of Node.js to use in CI workflows at github actions.
+   */
+  NODE_WORKFLOWS: "24",
+  /**
+   * Version of PNPM to use in workflows at github actions.
+   */
+  PNPM_VERSION: "10.33.0",
+  /**
+   * Version of Projen to use.
+   */
+  PROJEN_VERSION: "0.99.34",
+  /**
+   * What version of the turborepo library should we use?
+   */
+  TURBO_VERSION: "2.9.4",
+  /**
+   * What version of Vite to use (pnpm override). Pinned to 5.x so Vitest 4.x
+   * can load config (Vite 6+/7+ are ESM-only; see issue #142). Remove override
+   * when moving to ESM-only test setup.
+   */
+  VITE_VERSION: "5.4.11",
+  /**
+   * What version of Vitest to use when testRunner is 'vitest'.
+   * Pinned to 3.x so it works with Vite 5 (Vitest 4 requires Vite 6). See issue #142.
+   */
+  VITEST_VERSION: "3.2.4"
+};
+
+// src/vitest/vitest-component.ts
+var Vitest = class _Vitest extends import_projen2.Component {
+  constructor(project, options = {}) {
+    super(project);
+    this.project = project;
+    this.configFilePath = options.configFilePath ?? "vitest.config.ts";
+    const config = options.config ?? {};
+    this.include = config.include ?? ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
+    this.exclude = config.exclude ?? [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/lib/**",
+      "**/.?*"
+    ];
+    this.environment = config.environment ?? "node";
+    this.passWithNoTests = config.passWithNoTests ?? true;
+    this.coverageEnabled = config.coverageEnabled ?? true;
+    this.coverageDirectory = config.coverageDirectory ?? "coverage";
+    this.coverageReporters = config.coverageReporters ?? ["text", "lcov"];
+    this.version = options.vitestVersion ?? VERSION.VITEST_VERSION;
+    project.addDevDeps(`vitest@${this.version}`);
+    if (this.coverageEnabled) {
+      project.addDevDeps(`@vitest/coverage-v8@${this.version}`);
+    }
+    const coveragePath = `/${this.coverageDirectory}/`;
+    project.gitignore.addPatterns(coveragePath);
+    project.npmignore?.exclude(coveragePath);
+    this.addTestTasks();
+    this.synthesizeConfig();
+  }
+  /**
+   * Find the Vitest component on a project.
+   */
+  static of(project) {
+    const isVitest = (c) => c instanceof _Vitest;
+    return project.components.find(isVitest);
+  }
+  preSynthesize() {
+    super.preSynthesize();
+    for (const component of this.project.components) {
+      if (component instanceof import_javascript.Jest) {
+        throw new Error("Vitest cannot be used together with Jest");
+      }
+    }
+  }
+  addTestTasks() {
+    this.project.testTask.exec("vitest run --update");
+    if (!this.project.tasks.tryFind("test:watch")) {
+      this.project.addTask("test:watch", {
+        description: "Run tests in watch mode",
+        exec: "vitest watch",
+        receiveArgs: true
+      });
+    }
+  }
+  synthesizeConfig() {
+    this.project.tryRemoveFile(this.configFilePath);
+    new import_textfile.TextFile(this, this.configFilePath, {
+      lines: this.renderConfig()
+    });
+  }
+  renderConfig() {
+    return [
+      'import { defineConfig } from "vitest/config";',
+      "",
+      "export default defineConfig({",
+      "  test: {",
+      `    include: ${JSON.stringify(this.include)},`,
+      `    exclude: ${JSON.stringify(this.exclude)},`,
+      `    environment: "${this.environment}",`,
+      `    passWithNoTests: ${this.passWithNoTests},`,
+      "    coverage: {",
+      `      enabled: ${this.coverageEnabled},`,
+      `      provider: "v8",`,
+      `      reportsDirectory: "${this.coverageDirectory}",`,
+      `      reporter: ${JSON.stringify(this.coverageReporters)},`,
+      "    },",
+      "  },",
+      "});"
+    ];
+  }
+};
+
+// src/agent/bundles/vitest.ts
+var vitestBundle = {
+  name: "vitest",
+  description: "Vitest testing conventions, patterns, and file scoping",
+  appliesWhen: (project) => hasComponent(project, Vitest),
+  rules: [
+    {
+      name: "vitest-testing",
+      description: "Vitest testing conventions and patterns",
+      scope: AGENT_RULE_SCOPE.FILE_PATTERN,
+      filePatterns: ["**/*.test.ts", "**/*.spec.ts"],
+      content: [
+        "# Vitest Testing Patterns",
+        "",
+        "## Mandatory Requirements",
+        "",
+        "- **Tests MUST be created or updated whenever code functionality is added or changed**",
+        "- This applies to all code changes, including:",
+        "  - New features and functionality",
+        "  - Bug fixes",
+        "  - Refactoring that changes behavior",
+        "  - API changes",
+        "  - Configuration changes that affect functionality",
+        "- Tests should be written or updated as part of the same change that modifies the code",
+        "",
+        "## Test Structure",
+        "",
+        "- Use **Vitest** as the test runner",
+        "- Test files: `.spec.ts` or `.test.ts` (co-located with source)",
+        "- Use descriptive test names: `describe('ClassName', () => { it('should do something specific', () => {}) })`",
+        "- Prefer snapshot tests for complex object structures",
+        "- Mock external dependencies appropriately",
+        "",
+        "## Test Organization",
+        "",
+        "- Co-locate test files with source files",
+        "- Test files can use dev dependencies (ESLint rule override)",
+        "- Import from `vitest`: `import { describe, expect, it } from 'vitest'`",
+        "",
+        "## Example Test Structure",
+        "",
+        "```typescript",
+        "import { describe, expect, it } from 'vitest';",
+        "import { MyClass } from './my-class';",
+        "",
+        "describe('MyClass', () => {",
+        "  it('should do something specific', () => {",
+        "    // Test implementation",
+        "  });",
+        "});",
+        "```"
+      ].join("\n"),
+      tags: ["testing"]
+    }
+  ]
+};
+
+// src/agent/bundles/index.ts
+var BUILT_IN_BUNDLES = [
+  baseBundle,
+  typescriptBundle,
+  vitestBundle,
+  jestBundle,
+  turborepoBundle,
+  pnpmBundle,
+  awsCdkBundle,
+  projenBundle
+];
+
+// src/agent/renderers/claude-renderer.ts
+var import_projen5 = require("projen");
+var import_textfile2 = require("projen/lib/textfile");
+var GENERATED_MARKER = "<!-- ~~ Generated by @codedrifters/configulator. Edits welcome \u2014 please contribute improvements back. ~~ -->";
+var ClaudeRenderer = class _ClaudeRenderer {
+  /**
+   * Render all Claude Code configuration files.
+   */
+  static render(component, rules, skills, subAgents, mcpServers, settings) {
+    _ClaudeRenderer.renderClaudeMd(component, rules);
+    _ClaudeRenderer.renderScopedRules(component, rules);
+    _ClaudeRenderer.renderSettings(component, mcpServers, settings);
+    _ClaudeRenderer.renderSkills(component, skills);
+    _ClaudeRenderer.renderSubAgents(component, subAgents);
+  }
+  static renderClaudeMd(component, rules) {
+    const claudeMdRules = rules.filter((r) => {
+      if (r.platforms?.claude?.exclude) return false;
+      const target = r.platforms?.claude?.target ?? _ClaudeRenderer.defaultTarget(r);
+      return target === CLAUDE_RULE_TARGET.CLAUDE_MD;
+    });
+    if (claudeMdRules.length === 0) return;
+    const lines = [GENERATED_MARKER, ""];
+    for (let i = 0; i < claudeMdRules.length; i++) {
+      if (i > 0) lines.push("", "---", "");
+      lines.push(...claudeMdRules[i].content.split("\n"));
+    }
+    new import_textfile2.TextFile(component, "CLAUDE.md", { lines });
+  }
+  static renderScopedRules(component, rules) {
+    const scopedRules = rules.filter((r) => {
+      if (r.platforms?.claude?.exclude) return false;
+      const target = r.platforms?.claude?.target ?? _ClaudeRenderer.defaultTarget(r);
+      return target === CLAUDE_RULE_TARGET.SCOPED_FILE;
+    });
+    for (const rule of scopedRules) {
+      const lines = [];
+      if (rule.filePatterns && rule.filePatterns.length > 0) {
+        lines.push("---");
+        lines.push("paths:");
+        for (const pattern of rule.filePatterns) {
+          lines.push(`  - "${pattern}"`);
+        }
+        lines.push("---");
+        lines.push("");
+      }
+      lines.push(...rule.content.split("\n"));
+      new import_textfile2.TextFile(component, `.claude/rules/${rule.name}.md`, { lines });
+    }
+  }
+  static renderSettings(component, mcpServers, settings) {
+    const obj = {};
+    let hasContent = false;
+    if (settings?.defaultMode) {
+      obj.defaultMode = settings.defaultMode;
+      hasContent = true;
+    }
+    if (settings?.permissions) {
+      const perms = {};
+      if (settings.permissions.allow?.length) {
+        perms.allow = [...settings.permissions.allow];
+      }
+      if (settings.permissions.deny?.length) {
+        perms.deny = [...settings.permissions.deny];
+      }
+      if (settings.permissions.ask?.length) {
+        perms.ask = [...settings.permissions.ask];
+      }
+      if (settings.permissions.additionalDirectories?.length) {
+        perms.additionalDirectories = [
+          ...settings.permissions.additionalDirectories
+        ];
+      }
+      if (Object.keys(perms).length > 0) {
+        obj.permissions = perms;
+        hasContent = true;
+      }
+    }
+    if (settings?.hooks) {
+      const hooks = {};
+      for (const [event, entries] of Object.entries(settings.hooks)) {
+        if (entries && entries.length > 0) {
+          hooks[event] = entries;
+        }
+      }
+      if (Object.keys(hooks).length > 0) {
+        obj.hooks = hooks;
+        hasContent = true;
+      }
+    }
+    const allMcpServers = {};
+    for (const [name, config] of Object.entries(mcpServers)) {
+      const server = {};
+      if (config.command) server.command = config.command;
+      if (config.args) server.args = [...config.args];
+      if (config.url) server.url = config.url;
+      if (config.env) server.env = { ...config.env };
+      allMcpServers[name] = server;
+    }
+    if (settings?.mcpServers) {
+      for (const [name, config] of Object.entries(settings.mcpServers)) {
+        const server = {};
+        if (config.command) server.command = config.command;
+        if (config.args) server.args = [...config.args];
+        if (config.url) server.url = config.url;
+        if (config.env) server.env = { ...config.env };
+        allMcpServers[name] = server;
+      }
+    }
+    if (Object.keys(allMcpServers).length > 0) {
+      obj.mcpServers = allMcpServers;
+      hasContent = true;
+    }
+    if (settings?.allowedMcpServers?.length) {
+      obj.allowedMcpServers = [...settings.allowedMcpServers];
+      hasContent = true;
+    }
+    if (settings?.env && Object.keys(settings.env).length > 0) {
+      obj.env = { ...settings.env };
+      hasContent = true;
+    }
+    if (settings?.sandbox) {
+      obj.sandbox = _ClaudeRenderer.buildSandboxObj(settings.sandbox);
+      hasContent = true;
+    }
+    if (settings?.autoMode) {
+      const autoMode = {};
+      if (settings.autoMode.environment?.length) {
+        autoMode.environment = [...settings.autoMode.environment];
+      }
+      if (settings.autoMode.allow?.length) {
+        autoMode.allow = [...settings.autoMode.allow];
+      }
+      if (settings.autoMode.soft_deny?.length) {
+        autoMode.soft_deny = [...settings.autoMode.soft_deny];
+      }
+      if (Object.keys(autoMode).length > 0) {
+        obj.autoMode = autoMode;
+        hasContent = true;
+      }
+    }
+    if (settings?.disableBypassPermissionsMode) {
+      obj.disableBypassPermissionsMode = settings.disableBypassPermissionsMode;
+      hasContent = true;
+    }
+    if (settings?.disableAutoMode) {
+      obj.disableAutoMode = settings.disableAutoMode;
+      hasContent = true;
+    }
+    if (settings?.disableAllHooks !== void 0) {
+      obj.disableAllHooks = settings.disableAllHooks;
+      hasContent = true;
+    }
+    if (settings?.excludeSensitivePatterns?.length) {
+      obj.excludeSensitivePatterns = [...settings.excludeSensitivePatterns];
+      hasContent = true;
+    }
+    if (settings?.attribution) {
+      obj.attribution = settings.attribution;
+      hasContent = true;
+    }
+    if (!hasContent) return;
+    new import_projen5.JsonFile(component, ".claude/settings.json", { obj });
+  }
+  static buildSandboxObj(sandbox) {
+    const obj = {};
+    if (sandbox.enabled !== void 0) obj.enabled = sandbox.enabled;
+    if (sandbox.mode) obj.mode = sandbox.mode;
+    if (sandbox.failIfUnavailable !== void 0) {
+      obj.failIfUnavailable = sandbox.failIfUnavailable;
+    }
+    if (sandbox.autoAllowBashIfSandboxed !== void 0) {
+      obj.autoAllowBashIfSandboxed = sandbox.autoAllowBashIfSandboxed;
+    }
+    if (sandbox.excludedCommands?.length) {
+      obj.excludedCommands = [...sandbox.excludedCommands];
+    }
+    if (sandbox.filesystem) {
+      const fs = {};
+      if (sandbox.filesystem.allowRead?.length) {
+        fs.allowRead = [...sandbox.filesystem.allowRead];
+      }
+      if (sandbox.filesystem.denyRead?.length) {
+        fs.denyRead = [...sandbox.filesystem.denyRead];
+      }
+      if (sandbox.filesystem.allowWrite?.length) {
+        fs.allowWrite = [...sandbox.filesystem.allowWrite];
+      }
+      if (sandbox.filesystem.denyWrite?.length) {
+        fs.denyWrite = [...sandbox.filesystem.denyWrite];
+      }
+      if (Object.keys(fs).length > 0) obj.filesystem = fs;
+    }
+    if (sandbox.network) {
+      const net = {};
+      if (sandbox.network.allowedDomains?.length) {
+        net.allowedDomains = [...sandbox.network.allowedDomains];
+      }
+      if (sandbox.network.denyDomains?.length) {
+        net.denyDomains = [...sandbox.network.denyDomains];
+      }
+      if (Object.keys(net).length > 0) obj.network = net;
+    }
+    return obj;
+  }
+  static renderSkills(component, skills) {
+    for (const skill of skills) {
+      const lines = [];
+      lines.push("---");
+      lines.push(`name: "${skill.name}"`);
+      lines.push(`description: "${skill.description}"`);
+      if (skill.disableModelInvocation) {
+        lines.push(`disable-model-invocation: true`);
+      }
+      if (skill.userInvocable === false) {
+        lines.push(`user-invocable: false`);
+      }
+      if (skill.model) {
+        lines.push(`model: "${skill.model}"`);
+      }
+      if (skill.effort) {
+        lines.push(`effort: "${skill.effort}"`);
+      }
+      if (skill.paths && skill.paths.length > 0) {
+        lines.push(`paths:`);
+        for (const p of skill.paths) {
+          lines.push(`  - "${p}"`);
+        }
+      }
+      if (skill.allowedTools && skill.allowedTools.length > 0) {
+        lines.push(`allowed-tools:`);
+        for (const tool of skill.allowedTools) {
+          lines.push(`  - "${tool}"`);
+        }
+      }
+      lines.push("---");
+      lines.push("");
+      lines.push(...skill.instructions.split("\n"));
+      new import_textfile2.TextFile(component, `.claude/skills/${skill.name}/SKILL.md`, {
+        lines
+      });
+    }
+  }
+  static renderSubAgents(component, subAgents) {
+    for (const agent of subAgents) {
+      if (agent.platforms?.claude?.exclude) continue;
+      const lines = [];
+      lines.push("---");
+      lines.push(`name: ${agent.name}`);
+      lines.push(`description: >-`);
+      lines.push(`  ${agent.description}`);
+      if (agent.model) {
+        lines.push(`model: ${agent.model}`);
+      }
+      if (agent.tools && agent.tools.length > 0) {
+        lines.push(`tools:`);
+        for (const tool of agent.tools) {
+          lines.push(`  - "${tool}"`);
+        }
+      }
+      if (agent.maxTurns) {
+        lines.push(`max_turns: ${agent.maxTurns}`);
+      }
+      if (agent.platforms?.claude?.permissionMode) {
+        lines.push(`permission_mode: ${agent.platforms.claude.permissionMode}`);
+      }
+      if (agent.platforms?.claude?.isolation) {
+        lines.push(`isolation: ${agent.platforms.claude.isolation}`);
+      }
+      if (agent.platforms?.claude?.effort) {
+        lines.push(`effort: ${agent.platforms.claude.effort}`);
+      }
+      lines.push("---");
+      lines.push("");
+      lines.push(...agent.prompt.split("\n"));
+      new import_textfile2.TextFile(component, `.claude/agents/${agent.name}.md`, { lines });
+    }
+  }
+  /**
+   * Determine the default Claude rule target based on rule scope.
+   * ALWAYS-scoped rules default to CLAUDE_MD; FILE_PATTERN rules default to SCOPED_FILE.
+   */
+  static defaultTarget(rule) {
+    return rule.scope === AGENT_RULE_SCOPE.ALWAYS ? CLAUDE_RULE_TARGET.CLAUDE_MD : CLAUDE_RULE_TARGET.SCOPED_FILE;
+  }
+};
+
+// src/agent/renderers/codex-renderer.ts
+var CodexRenderer = class {
+  static render(_component, _rules, _skills, _subAgents) {
+  }
+};
+
+// src/agent/renderers/copilot-renderer.ts
+var CopilotRenderer = class {
+  static render(_component, _rules, _skills, _subAgents) {
+  }
+};
+
+// src/agent/renderers/cursor-renderer.ts
+var import_projen6 = require("projen");
+var import_textfile3 = require("projen/lib/textfile");
+var GENERATED_MARKER2 = "# ~~ Generated by @codedrifters/configulator. Edits welcome \u2014 please contribute improvements back. ~~";
+var CursorRenderer = class _CursorRenderer {
+  /**
+   * Render all Cursor configuration files.
+   */
+  static render(component, rules, skills, subAgents, mcpServers, settings) {
+    _CursorRenderer.renderRules(component, rules);
+    _CursorRenderer.renderSkills(component, skills);
+    _CursorRenderer.renderSubAgents(component, subAgents);
+    _CursorRenderer.renderMcpServers(component, mcpServers);
+    _CursorRenderer.renderHooks(component, settings);
+    _CursorRenderer.renderIgnoreFiles(component, settings);
+  }
+  static renderRules(component, rules) {
+    for (const rule of rules) {
+      if (rule.platforms?.cursor?.exclude) continue;
+      const lines = [];
+      const description = rule.platforms?.cursor?.description ?? rule.description;
+      const isAlways = rule.scope === AGENT_RULE_SCOPE.ALWAYS;
+      lines.push("---");
+      lines.push(`description: "${description}"`);
+      lines.push(`alwaysApply: ${isAlways}`);
+      if (!isAlways && rule.filePatterns && rule.filePatterns.length > 0) {
+        lines.push(`path: ${JSON.stringify([...rule.filePatterns])}`);
+      }
+      lines.push("---");
+      lines.push("");
+      lines.push(...rule.content.split("\n"));
+      new import_textfile3.TextFile(component, `.cursor/rules/${rule.name}.mdc`, { lines });
+    }
+  }
+  static renderSkills(component, skills) {
+    for (const skill of skills) {
+      const lines = [];
+      lines.push("---");
+      lines.push(`name: "${skill.name}"`);
+      lines.push(`description: "${skill.description}"`);
+      if (skill.disableModelInvocation) {
+        lines.push(`disable-model-invocation: true`);
+      }
+      if (skill.userInvocable === false) {
+        lines.push(`user-invocable: false`);
+      }
+      if (skill.allowedTools && skill.allowedTools.length > 0) {
+        lines.push(`allowed-tools:`);
+        for (const tool of skill.allowedTools) {
+          lines.push(`  - "${tool}"`);
+        }
+      }
+      lines.push("---");
+      lines.push("");
+      lines.push(...skill.instructions.split("\n"));
+      new import_textfile3.TextFile(component, `.cursor/skills/${skill.name}/SKILL.md`, {
+        lines
+      });
+    }
+  }
+  static renderSubAgents(component, subAgents) {
+    for (const agent of subAgents) {
+      if (agent.platforms?.cursor?.exclude) continue;
+      const lines = [];
+      lines.push("---");
+      lines.push(`name: ${agent.name}`);
+      lines.push(`description: >-`);
+      lines.push(`  ${agent.description}`);
+      if (agent.model) {
+        lines.push(`model: ${agent.model}`);
+      }
+      if (agent.platforms?.cursor?.readonly) {
+        lines.push(`readonly: true`);
+      }
+      if (agent.platforms?.cursor?.isBackground) {
+        lines.push(`is_background: true`);
+      }
+      lines.push("---");
+      lines.push("");
+      lines.push(...agent.prompt.split("\n"));
+      new import_textfile3.TextFile(component, `.cursor/agents/${agent.name}.md`, { lines });
+    }
+  }
+  static renderMcpServers(component, mcpServers) {
+    const serverNames = Object.keys(mcpServers);
+    if (serverNames.length === 0) return;
+    const obj = { mcpServers: {} };
+    const servers = obj.mcpServers;
+    for (const [name, config] of Object.entries(mcpServers)) {
+      const server = {};
+      if (config.command) server.command = config.command;
+      if (config.args) server.args = [...config.args];
+      if (config.url) server.url = config.url;
+      if (config.env) server.env = { ...config.env };
+      servers[name] = server;
+    }
+    new import_projen6.JsonFile(component, ".cursor/mcp.json", { obj });
+  }
+  static renderHooks(component, settings) {
+    if (!settings?.hooks) return;
+    const hooks = {};
+    const {
+      beforeSubmitPrompt,
+      beforeShellExecution,
+      beforeMCPExecution,
+      beforeReadFile,
+      afterFileEdit,
+      stop
+    } = settings.hooks;
+    if (beforeSubmitPrompt?.length) {
+      hooks.beforeSubmitPrompt = beforeSubmitPrompt.map((h) => ({
+        command: h.command
+      }));
+    }
+    if (beforeShellExecution?.length) {
+      hooks.beforeShellExecution = beforeShellExecution.map((h) => ({
+        command: h.command
+      }));
+    }
+    if (beforeMCPExecution?.length) {
+      hooks.beforeMCPExecution = beforeMCPExecution.map((h) => ({
+        command: h.command
+      }));
+    }
+    if (beforeReadFile?.length) {
+      hooks.beforeReadFile = beforeReadFile.map((h) => ({
+        command: h.command
+      }));
+    }
+    if (afterFileEdit?.length) {
+      hooks.afterFileEdit = afterFileEdit.map((h) => ({ command: h.command }));
+    }
+    if (stop?.length) hooks.stop = stop.map((h) => ({ command: h.command }));
+    if (Object.keys(hooks).length === 0) return;
+    new import_projen6.JsonFile(component, ".cursor/hooks.json", {
+      obj: { version: 1, hooks }
+    });
+  }
+  static renderIgnoreFiles(component, settings) {
+    if (settings?.ignorePatterns && settings.ignorePatterns.length > 0) {
+      new import_textfile3.TextFile(component, ".cursorignore", {
+        lines: [GENERATED_MARKER2, "", ...settings.ignorePatterns]
+      });
+    }
+    if (settings?.indexingIgnorePatterns && settings.indexingIgnorePatterns.length > 0) {
+      new import_textfile3.TextFile(component, ".cursorindexingignore", {
+        lines: [GENERATED_MARKER2, "", ...settings.indexingIgnorePatterns]
+      });
+    }
+  }
+};
+
+// src/agent/agent-config.ts
+var AgentConfig = class _AgentConfig extends import_projen7.Component {
+  /**
+   * Find the AgentConfig component on a project.
+   */
+  static of(project) {
+    const isAgentConfig = (c) => c instanceof _AgentConfig;
+    return project.components.find(isAgentConfig);
+  }
+  constructor(project, options = {}) {
+    super(project);
+    this.options = options;
+  }
+  preSynthesize() {
+    super.preSynthesize();
+    const platforms = this.resolvePlatforms();
+    const rules = this.resolveRules();
+    const skills = this.resolveSkills();
+    const subAgents = this.resolveSubAgents();
+    const mcpServers = this.options.mcpServers ?? {};
+    if (platforms.includes(AGENT_PLATFORM.CURSOR)) {
+      CursorRenderer.render(
+        this,
+        rules,
+        skills,
+        subAgents,
+        mcpServers,
+        this.options.cursorSettings
+      );
+    }
+    if (platforms.includes(AGENT_PLATFORM.CLAUDE)) {
+      ClaudeRenderer.render(
+        this,
+        rules,
+        skills,
+        subAgents,
+        mcpServers,
+        this.options.claudeSettings
+      );
+    }
+    if (platforms.includes(AGENT_PLATFORM.CODEX)) {
+      CodexRenderer.render(this, rules, skills, subAgents);
+    }
+    if (platforms.includes(AGENT_PLATFORM.COPILOT)) {
+      CopilotRenderer.render(this, rules, skills, subAgents);
+    }
+  }
+  resolvePlatforms() {
+    return this.options.platforms ?? [AGENT_PLATFORM.CURSOR, AGENT_PLATFORM.CLAUDE];
+  }
+  resolveRules() {
+    const ruleMap = /* @__PURE__ */ new Map();
+    if (this.options.autoDetectBundles !== false) {
+      for (const bundle of BUILT_IN_BUNDLES) {
+        if (this.options.excludeBundles?.includes(bundle.name)) continue;
+        if (bundle.name === "base" && this.options.includeBaseRules === false) {
+          continue;
+        }
+        if (bundle.appliesWhen(this.project)) {
+          for (const rule of bundle.rules) {
+            ruleMap.set(rule.name, rule);
+          }
+        }
+      }
+    }
+    if (this.options.includeBundles) {
+      for (const bundleName of this.options.includeBundles) {
+        const bundle = BUILT_IN_BUNDLES.find((b) => b.name === bundleName);
+        if (bundle) {
+          for (const rule of bundle.rules) {
+            ruleMap.set(rule.name, rule);
+          }
+        }
+      }
+    }
+    if (this.options.rules) {
+      for (const rule of this.options.rules) {
+        ruleMap.set(rule.name, rule);
+      }
+    }
+    if (this.options.excludeRules) {
+      for (const name of this.options.excludeRules) {
+        ruleMap.delete(name);
+      }
+    }
+    if (this.options.ruleExtensions) {
+      for (const [name, extra] of Object.entries(this.options.ruleExtensions)) {
+        const existing = ruleMap.get(name);
+        if (existing) {
+          ruleMap.set(name, {
+            ...existing,
+            content: `${existing.content}
+
+---
+
+${extra}`
+          });
+        }
+      }
+    }
+    return [...ruleMap.values()].sort((a, b) => {
+      if (a.name === "project-overview") return -1;
+      if (b.name === "project-overview") return 1;
+      const tagA = a.tags?.[0] ?? "\uFFFF";
+      const tagB = b.tags?.[0] ?? "\uFFFF";
+      if (tagA !== tagB) return tagA.localeCompare(tagB);
+      return a.name.localeCompare(b.name);
+    });
+  }
+  resolveSkills() {
+    const skillMap = /* @__PURE__ */ new Map();
+    if (this.options.autoDetectBundles !== false) {
+      for (const bundle of BUILT_IN_BUNDLES) {
+        if (this.options.excludeBundles?.includes(bundle.name)) continue;
+        if (bundle.appliesWhen(this.project) && bundle.skills) {
+          for (const skill of bundle.skills) {
+            skillMap.set(skill.name, skill);
+          }
+        }
       }
-    });
-    super.preSynthesize();
+    }
+    if (this.options.skills) {
+      for (const skill of this.options.skills) {
+        skillMap.set(skill.name, skill);
+      }
+    }
+    return [...skillMap.values()];
   }
-};
-_TurboRepo.buildWorkflowOptions = (remoteCacheOptions) => {
-  return {
-    env: {
-      GIT_BRANCH_NAME: "${{ github.head_ref || github.ref_name }}"
-    },
-    permissions: {
-      contents: import_workflows_model.JobPermission.WRITE,
-      idToken: import_workflows_model.JobPermission.WRITE
-    },
-    preBuildSteps: [
-      {
-        name: "AWS Creds for SSM",
-        uses: "aws-actions/configure-aws-credentials@v4",
-        with: {
-          ["role-to-assume"]: remoteCacheOptions.oidcRole,
-          ["aws-region"]: "us-east-1",
-          ["role-duration-seconds"]: "900"
+  resolveSubAgents() {
+    const agentMap = /* @__PURE__ */ new Map();
+    if (this.options.autoDetectBundles !== false) {
+      for (const bundle of BUILT_IN_BUNDLES) {
+        if (this.options.excludeBundles?.includes(bundle.name)) continue;
+        if (bundle.appliesWhen(this.project) && bundle.subAgents) {
+          for (const agent of bundle.subAgents) {
+            agentMap.set(agent.name, agent);
+          }
         }
       }
-    ]
-  };
+    }
+    if (this.options.subAgents) {
+      for (const agent of this.options.subAgents) {
+        agentMap.set(agent.name, agent);
+      }
+    }
+    return [...agentMap.values()];
+  }
 };
-var TurboRepo = _TurboRepo;
 
 // src/aws/aws-deployment-config.ts
-var AwsDeploymentConfig = class _AwsDeploymentConfig extends import_projen.Component {
+var import_node_path = require("path");
+var import_utils8 = __toESM(require_lib());
+var import_projen8 = require("projen");
+var AwsDeploymentConfig = class _AwsDeploymentConfig extends import_projen8.Component {
   constructor(project) {
     super(project);
     /**
@@ -514,17 +1962,17 @@ var AwsDeploymentConfig = class _AwsDeploymentConfig extends import_projen.Compo
    */
   get prodTargets() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.PROD
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.PROD
     );
   }
   get prodTargetsForCI() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.PROD && target.ciDeployment
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.PROD && target.ciDeployment
     );
   }
   get prodTargetsForLocal() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.PROD && target.localDeployment
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.PROD && target.localDeployment
     );
   }
   /**
@@ -533,17 +1981,17 @@ var AwsDeploymentConfig = class _AwsDeploymentConfig extends import_projen.Compo
    */
   get stageTargets() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.STAGE
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.STAGE
     );
   }
   get stageTargetsForCI() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.STAGE && target.ciDeployment
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.STAGE && target.ciDeployment
     );
   }
   get stageTargetsForLocal() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.STAGE && target.localDeployment
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.STAGE && target.localDeployment
     );
   }
   /**
@@ -552,17 +2000,17 @@ var AwsDeploymentConfig = class _AwsDeploymentConfig extends import_projen.Compo
    */
   get devTargets() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.DEV
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.DEV
     );
   }
   get devTargetsForCI() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.DEV && target.ciDeployment
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.DEV && target.ciDeployment
     );
   }
   get devTargetsForLocal() {
     return this.awsDeploymentTargets.filter(
-      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.DEV && target.localDeployment
+      (target) => target.awsStageType === import_utils8.AWS_STAGE_TYPE.DEV && target.localDeployment
     );
   }
   preSynthesize() {
@@ -575,9 +2023,9 @@ var AwsDeploymentConfig = class _AwsDeploymentConfig extends import_projen.Compo
 };
 
 // src/aws/aws-deployment-target.ts
-var import_utils2 = __toESM(require_lib());
-var import_projen2 = require("projen");
-var AwsDeploymentTarget = class _AwsDeploymentTarget extends import_projen2.Component {
+var import_utils9 = __toESM(require_lib());
+var import_projen9 = require("projen");
+var AwsDeploymentTarget = class _AwsDeploymentTarget extends import_projen9.Component {
   constructor(project, options) {
     super(project);
     /**
@@ -642,11 +2090,11 @@ var AwsDeploymentTarget = class _AwsDeploymentTarget extends import_projen2.Comp
     };
     this.account = options.account;
     this.region = options.region;
-    this.awsStageType = options.awsStageType || import_utils2.AWS_STAGE_TYPE.DEV;
-    const role = options.deploymentTargetRole ?? options.awsEnvironmentType ?? import_utils2.DEPLOYMENT_TARGET_ROLE.PRIMARY;
+    this.awsStageType = options.awsStageType || import_utils9.AWS_STAGE_TYPE.DEV;
+    const role = options.deploymentTargetRole ?? options.awsEnvironmentType ?? import_utils9.DEPLOYMENT_TARGET_ROLE.PRIMARY;
     this.deploymentTargetRole = role;
     this.awsEnvironmentType = role;
-    this.branches = options.branches ?? (this.awsStageType === import_utils2.AWS_STAGE_TYPE.PROD ? [
+    this.branches = options.branches ?? (this.awsStageType === import_utils9.AWS_STAGE_TYPE.PROD ? [
       {
         branch: "main"
       }
@@ -655,7 +2103,7 @@ var AwsDeploymentTarget = class _AwsDeploymentTarget extends import_projen2.Comp
         branch: "feature/*"
       }
     ]);
-    this.localDeployment = options.localDeployment ?? this.awsStageType === import_utils2.AWS_STAGE_TYPE.DEV;
+    this.localDeployment = options.localDeployment ?? this.awsStageType === import_utils9.AWS_STAGE_TYPE.DEV;
     if (this.localDeployment) {
       const roleName = options.localDeploymentConfig?.roleName?.toLowerCase() || "poweruseraccess";
       const profile = options.localDeploymentConfig?.profile || `${roleName}-${this.awsStageType}-${this.account}-${this.region}`;
@@ -790,61 +2238,14 @@ var VERSION_KEYS_SKIP = [
   // Pinned to 3.x for Vite 5 compatibility; skip until ESM-only (issue #142)
 ];
 
-// src/versions.ts
-var VERSION = {
-  /**
-   * CDK CLI for workflows and command line operations.
-   *
-   * CLI and lib are versioned separately, so this is the CLI version.
-   */
-  AWS_CDK_CLI_VERSION: "2.1117.0",
-  /**
-   * CDK Version to use for construct projects.
-   *
-   * CLI and lib are versioned separately, so this is the lib version.
-   */
-  AWS_CDK_LIB_VERSION: "2.248.0",
-  /**
-   * Version of the AWS Constructs library to use.
-   */
-  AWS_CONSTRUCTS_VERSION: "10.6.0",
-  /**
-   * Version of Node.js to use in CI workflows at github actions.
-   */
-  NODE_WORKFLOWS: "24",
-  /**
-   * Version of PNPM to use in workflows at github actions.
-   */
-  PNPM_VERSION: "10.33.0",
-  /**
-   * Version of Projen to use.
-   */
-  PROJEN_VERSION: "0.99.34",
-  /**
-   * What version of the turborepo library should we use?
-   */
-  TURBO_VERSION: "2.9.4",
-  /**
-   * What version of Vite to use (pnpm override). Pinned to 5.x so Vitest 4.x
-   * can load config (Vite 6+/7+ are ESM-only; see issue #142). Remove override
-   * when moving to ESM-only test setup.
-   */
-  VITE_VERSION: "5.4.11",
-  /**
-   * What version of Vitest to use when testRunner is 'vitest'.
-   * Pinned to 3.x so it works with Vite 5 (Vitest 4 requires Vite 6). See issue #142.
-   */
-  VITEST_VERSION: "3.2.4"
-};
-
 // src/jsii/jsii-faker.ts
 var spec = __toESM(require("@jsii/spec"));
-var import_projen3 = require("projen");
+var import_projen10 = require("projen");
 var ProjenBaseFqn = {
   TYPESCRIPT_PROJECT: "projen.typescript.TypeScriptProject",
   TYPESCRIPT_PROJECT_OPTIONS: "projen.typescript.TypeScriptProjectOptions"
 };
-var JsiiFaker = class _JsiiFaker extends import_projen3.Component {
+var JsiiFaker = class _JsiiFaker extends import_projen10.Component {
   constructor(project) {
     super(project);
     this.project = project;
@@ -855,7 +2256,7 @@ var JsiiFaker = class _JsiiFaker extends import_projen3.Component {
       };
     };
     this._assemblyName = this.project.package.packageName;
-    new import_projen3.JsonFile(project, ".jsii", {
+    new import_projen10.JsonFile(project, ".jsii", {
       obj: () => {
         return {
           name: this._assemblyName,
@@ -892,192 +2293,24 @@ var JsiiFaker = class _JsiiFaker extends import_projen3.Component {
   }
 };
 
-// src/pnpm/pnpm-workspace.ts
-var import_path = require("path");
-var import_projen4 = require("projen");
-var MIMIMUM_RELEASE_AGE = {
-  ZERO_DAYS: 0,
-  ONE_HOUR: 60,
-  SIX_HOURS: 360,
-  TWELVE_HOURS: 720,
-  ONE_DAY: 1440,
-  TWO_DAYS: 2880,
-  THREE_DAYS: 4320,
-  FOUR_DAYS: 5760,
-  FIVE_DAYS: 7200,
-  SIX_DAYS: 8640,
-  ONE_WEEK: 10080
-};
-var PnpmWorkspace = class _PnpmWorkspace extends import_projen4.Component {
-  /**
-   * Get the pnpm workspace component of a project. If it does not exist,
-   * return undefined.
-   *
-   * @param project
-   * @returns
-   */
-  static of(project) {
-    const isDefined = (c) => c instanceof _PnpmWorkspace;
-    return project.root.components.find(isDefined);
-  }
-  constructor(project, options = {}) {
-    super(project);
-    project.tryFindObjectFile("package.json")?.addDeletionOverride("pnpm");
-    this.fileName = options.fileName ?? "pnpm-workspace.yaml";
-    this.minimumReleaseAge = options.minimumReleaseAge ?? MIMIMUM_RELEASE_AGE.ONE_DAY;
-    this.minimumReleaseAgeExclude = options.minimumReleaseAgeExclude ? ["@codedrifters/*", ...options.minimumReleaseAgeExclude] : ["@codedrifters/*"];
-    this.onlyBuiltDependencies = options.onlyBuiltDependencies ? options.onlyBuiltDependencies : [];
-    this.ignoredBuiltDependencies = options.ignoredBuiltDependencies ? options.ignoredBuiltDependencies : [];
-    this.subprojects = options.subprojects ?? [];
-    this.defaultCatalog = options.defaultCatalog;
-    this.namedCatalogs = options.namedCatalogs;
-    project.addPackageIgnore(this.fileName);
-    new import_projen4.YamlFile(this.project, this.fileName, {
-      obj: () => {
-        const pnpmConfig = {};
-        const packages = new Array();
-        for (const subproject of project.subprojects) {
-          packages.push((0, import_path.relative)(this.project.outdir, subproject.outdir));
-        }
-        const packageSet = new Set(packages);
-        for (const subprojectPath of this.subprojects) {
-          packageSet.add(subprojectPath);
-        }
-        if (this.subprojects.length > 0) {
-          packages.length = 0;
-          packages.push(...packageSet);
-        }
-        pnpmConfig.minimumReleaseAge = this.minimumReleaseAge;
-        if (this.minimumReleaseAgeExclude.length > 0) {
-          pnpmConfig.minimumReleaseAgeExclude = this.minimumReleaseAgeExclude;
-        }
-        if (this.onlyBuiltDependencies.length > 0) {
-          pnpmConfig.onlyBuiltDependencies = this.onlyBuiltDependencies;
-        }
-        if (this.ignoredBuiltDependencies.length > 0) {
-          pnpmConfig.ignoreBuiltDependencies = this.ignoredBuiltDependencies;
-        }
-        if (this.defaultCatalog && Object.keys(this.defaultCatalog).length > 0) {
-          pnpmConfig.catalog = this.defaultCatalog;
-        }
-        if (this.namedCatalogs && Object.keys(this.namedCatalogs).length > 0) {
-          pnpmConfig.namedCatalogs = this.namedCatalogs;
-        }
-        return {
-          ...packages.length > 0 ? { packages } : {},
-          ...pnpmConfig ? { ...pnpmConfig } : {}
-        };
-      }
-    });
-  }
-};
-
 // src/projects/monorepo-project.ts
 var import_javascript3 = require("projen/lib/javascript");
-var import_typescript = require("projen/lib/typescript");
+var import_typescript3 = require("projen/lib/typescript");
 var import_ts_deepmerge2 = require("ts-deepmerge");
 
 // src/tasks/reset-task.ts
-var import_projen7 = require("projen");
+var import_projen12 = require("projen");
 
 // src/projects/typescript-project.ts
-var import_projen6 = require("projen");
+var import_projen11 = require("projen");
 var import_javascript2 = require("projen/lib/javascript");
 var import_release = require("projen/lib/release");
 var import_ts_deepmerge = require("ts-deepmerge");
-
-// src/vitest/vitest-component.ts
-var import_projen5 = require("projen");
-var import_javascript = require("projen/lib/javascript");
-var import_textfile = require("projen/lib/textfile");
-var Vitest = class _Vitest extends import_projen5.Component {
-  constructor(project, options = {}) {
-    super(project);
-    this.project = project;
-    this.configFilePath = options.configFilePath ?? "vitest.config.ts";
-    const config = options.config ?? {};
-    this.include = config.include ?? ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
-    this.exclude = config.exclude ?? [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/lib/**",
-      "**/.?*"
-    ];
-    this.environment = config.environment ?? "node";
-    this.passWithNoTests = config.passWithNoTests ?? true;
-    this.coverageEnabled = config.coverageEnabled ?? true;
-    this.coverageDirectory = config.coverageDirectory ?? "coverage";
-    this.coverageReporters = config.coverageReporters ?? ["text", "lcov"];
-    this.version = options.vitestVersion ?? VERSION.VITEST_VERSION;
-    project.addDevDeps(`vitest@${this.version}`);
-    if (this.coverageEnabled) {
-      project.addDevDeps(`@vitest/coverage-v8@${this.version}`);
-    }
-    const coveragePath = `/${this.coverageDirectory}/`;
-    project.gitignore.addPatterns(coveragePath);
-    project.npmignore?.exclude(coveragePath);
-    this.addTestTasks();
-    this.synthesizeConfig();
-  }
-  /**
-   * Find the Vitest component on a project.
-   */
-  static of(project) {
-    const isVitest = (c) => c instanceof _Vitest;
-    return project.components.find(isVitest);
-  }
-  preSynthesize() {
-    super.preSynthesize();
-    for (const component of this.project.components) {
-      if (component instanceof import_javascript.Jest) {
-        throw new Error("Vitest cannot be used together with Jest");
-      }
-    }
-  }
-  addTestTasks() {
-    this.project.testTask.exec("vitest run --update");
-    if (!this.project.tasks.tryFind("test:watch")) {
-      this.project.addTask("test:watch", {
-        description: "Run tests in watch mode",
-        exec: "vitest watch",
-        receiveArgs: true
-      });
-    }
-  }
-  synthesizeConfig() {
-    this.project.tryRemoveFile(this.configFilePath);
-    new import_textfile.TextFile(this, this.configFilePath, {
-      lines: this.renderConfig()
-    });
-  }
-  renderConfig() {
-    return [
-      'import { defineConfig } from "vitest/config";',
-      "",
-      "export default defineConfig({",
-      "  test: {",
-      `    include: ${JSON.stringify(this.include)},`,
-      `    exclude: ${JSON.stringify(this.exclude)},`,
-      `    environment: "${this.environment}",`,
-      `    passWithNoTests: ${this.passWithNoTests},`,
-      "    coverage: {",
-      `      enabled: ${this.coverageEnabled},`,
-      `      provider: "v8",`,
-      `      reportsDirectory: "${this.coverageDirectory}",`,
-      `      reporter: ${JSON.stringify(this.coverageReporters)},`,
-      "    },",
-      "  },",
-      "});"
-    ];
-  }
-};
-
-// src/projects/typescript-project.ts
 var TestRunner = {
   JEST: "jest",
   VITEST: "vitest"
 };
-var TypeScriptProject = class extends import_projen6.typescript.TypeScriptProject {
+var TypeScriptProject = class extends import_projen11.typescript.TypeScriptProject {
   constructor(userOptions) {
     const pnpmVersion = userOptions.parent && userOptions.parent instanceof MonorepoProject ? userOptions.parent.pnpmVersion : VERSION.PNPM_VERSION;
     const pnpmWorkspace = userOptions.parent && userOptions.parent instanceof MonorepoProject ? PnpmWorkspace.of(userOptions.parent) : void 0;
@@ -1237,7 +2470,7 @@ var TypeScriptProject = class extends import_projen6.typescript.TypeScriptProjec
 };
 
 // src/tasks/reset-task.ts
-var ResetTask = class _ResetTask extends import_projen7.Component {
+var ResetTask = class _ResetTask extends import_projen12.Component {
   constructor(project, options = {}) {
     super(project);
     this.project = project;
@@ -1310,12 +2543,12 @@ var ResetTask = class _ResetTask extends import_projen7.Component {
 };
 
 // src/vscode/vscode.ts
-var import_projen8 = require("projen");
-var VSCodeConfig = class extends import_projen8.Component {
+var import_projen13 = require("projen");
+var VSCodeConfig = class extends import_projen13.Component {
   constructor(project) {
     super(project);
-    const vsConfig = new import_projen8.vscode.VsCode(project);
-    const vsSettings = new import_projen8.vscode.VsCodeSettings(vsConfig);
+    const vsConfig = new import_projen13.vscode.VsCode(project);
+    const vsSettings = new import_projen13.vscode.VsCodeSettings(vsConfig);
     vsSettings.addSetting("editor.tabSize", 2);
     vsSettings.addSetting("editor.detectIndentation", false);
     vsSettings.addSetting("editor.bracketPairColorization.enabled", true);
@@ -1459,7 +2692,7 @@ function addBuildCompleteJob(buildWorkflow) {
 // src/projects/monorepo-project.ts
 var CONFIGULATOR_PACKAGE_NAME = "@codedrifters/configulator";
 var postInstallDependenciesMap = /* @__PURE__ */ new WeakMap();
-var MonorepoProject = class extends import_typescript.TypeScriptAppProject {
+var MonorepoProject = class extends import_typescript3.TypeScriptAppProject {
   constructor(userOptions) {
     const buildWorkflowOptions = userOptions.turboOptions?.remoteCacheOptions ? TurboRepo.buildWorkflowOptions(
       userOptions.turboOptions.remoteCacheOptions
@@ -1687,6 +2920,9 @@ var MonorepoProject = class extends import_typescript.TypeScriptAppProject {
     if (options.approveMergeUpgradeOptions) {
       addApproveMergeUpgradeWorkflow(this, options.approveMergeUpgradeOptions);
     }
+    if (options.agentConfig) {
+      new AgentConfig(this, options.agentConfigOptions);
+    }
     if (this.buildWorkflow) {
       addBuildCompleteJob(this.buildWorkflow);
     }
@@ -1745,9 +2981,9 @@ var MonorepoProject = class extends import_typescript.TypeScriptAppProject {
 
 // src/typescript/typescript-config.ts
 var import_node_path2 = require("path");
-var import_projen9 = require("projen");
+var import_projen14 = require("projen");
 var import_path2 = require("projen/lib/util/path");
-var TypeScriptConfig = class extends import_projen9.Component {
+var TypeScriptConfig = class extends import_projen14.Component {
   constructor(project) {
     super(project);
     let tsPaths = {};
@@ -1774,13 +3010,13 @@ var TypeScriptConfig = class extends import_projen9.Component {
 };
 
 // src/workflows/aws-deploy-workflow.ts
-var import_utils3 = __toESM(require_lib());
-var import_projen10 = require("projen");
+var import_utils10 = __toESM(require_lib());
+var import_projen15 = require("projen");
 var import_build = require("projen/lib/build");
 var import_github = require("projen/lib/github");
 var import_workflows_model4 = require("projen/lib/github/workflows-model");
 var PROD_DEPLOY_NAME = "prod-deploy";
-var AwsDeployWorkflow = class _AwsDeployWorkflow extends import_projen10.Component {
+var AwsDeployWorkflow = class _AwsDeployWorkflow extends import_projen15.Component {
   constructor(project, options = {}) {
     super(project);
     this.project = project;
@@ -1791,7 +3027,7 @@ var AwsDeployWorkflow = class _AwsDeployWorkflow extends import_projen10.Compone
      * @deprecated Use deployment target role terminology elsewhere. This property is maintained for backward compatibility.
      * @default 'primary' (this is the only type supported currently)
      */
-    this.awsEnvironmentType = import_utils3.DEPLOYMENT_TARGET_ROLE.PRIMARY;
+    this.awsEnvironmentType = import_utils10.DEPLOYMENT_TARGET_ROLE.PRIMARY;
     this.setupNode = () => {
       return [
         {
@@ -1901,7 +3137,7 @@ var AwsDeployWorkflow = class _AwsDeployWorkflow extends import_projen10.Compone
     }
     const turbo = TurboRepo.of(this.rootProject);
     const buildWorkflowOptions = turbo?.remoteCacheOptions ? TurboRepo.buildWorkflowOptions(turbo.remoteCacheOptions) : {};
-    this.awsStageType = options.awsStageType ?? import_utils3.AWS_STAGE_TYPE.DEV;
+    this.awsStageType = options.awsStageType ?? import_utils10.AWS_STAGE_TYPE.DEV;
     this.awsDeploymentTargets = options.awsDeploymentTargets ?? AwsDeploymentConfig.of(project)?.awsDeploymentTargets.filter(
       (target) => target.awsStageType === this.awsStageType && target.ciDeployment
     ) ?? [];
@@ -2045,11 +3281,18 @@ var AwsDeployWorkflow = class _AwsDeployWorkflow extends import_projen10.Compone
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AGENT_MODEL,
+  AGENT_PLATFORM,
+  AGENT_RULE_SCOPE,
+  AgentConfig,
   AwsDeployWorkflow,
   AwsDeploymentConfig,
   AwsDeploymentTarget,
+  BUILT_IN_BUNDLES,
+  CLAUDE_RULE_TARGET,
   COMPLETE_JOB_ID,
   JsiiFaker,
+  MCP_TRANSPORT,
   MERGE_METHODS,
   MIMIMUM_RELEASE_AGE,
   MonorepoProject,
@@ -2070,6 +3313,14 @@ var AwsDeployWorkflow = class _AwsDeployWorkflow extends import_projen10.Compone
   Vitest,
   addApproveMergeUpgradeWorkflow,
   addBuildCompleteJob,
-  getLatestEligibleVersion
+  awsCdkBundle,
+  baseBundle,
+  getLatestEligibleVersion,
+  jestBundle,
+  pnpmBundle,
+  projenBundle,
+  turborepoBundle,
+  typescriptBundle,
+  vitestBundle
 });
 //# sourceMappingURL=index.js.map