@jaypie/mcp 0.1.10 → 0.2.1

package/prompts/Templates_CDK_Subpackage.md

@@ -0,0 +1,113 @@
+---
+description: Template files for creating a CDK subpackage in a Jaypie monorepo
+---
+
+# CDK Subpackage Templates
+
+Templates for creating a CDK (AWS Cloud Development Kit) subpackage in a Jaypie monorepo.
+
+## bin/cdk.ts
+
+```typescript
+#!/usr/bin/env node
+
+import cdk from "aws-cdk-lib";
+import { AppStack } from "../lib/cdk-app.ts";
+import { InfrastructureStack } from "../lib/cdk-infrastructure.ts";
+
+const app = new cdk.App();
+
+new InfrastructureStack(app, "InfrastructureStack");
+
+new AppStack(app, "AppStack");
+```
+
+## lib/cdk-app.ts
+
+```typescript
+import {
+  JaypieAppStack,
+  JaypieApiGateway,
+  JaypieExpressLambda,
+  JaypieMongoDbSecret,
+  JaypieLambda,
+} from "@jaypie/constructs";
+
+import * as cdk from "aws-cdk-lib";
+import { Construct } from "constructs";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+
+export class AppStack extends JaypieAppStack {
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const mongoConnectionString = new JaypieMongoDbSecret(this);
+
+    const expressLambda = new JaypieExpressLambda(this, "expressLambda", {
+      code: lambda.Code.fromAsset("../express"),
+      handler: "dist/index.expressLambda",
+      secrets: [mongoConnectionString],
+    });
+
+    new JaypieApiGateway(this, "apiGateway", {
+      handler: expressLambda,
+      host: "api.example.com",
+      zone: "example.com",
+    });
+
+    new JaypieLambda(
+      this,
+      "lambdaWorker",
+      {
+        code: lambda.Code.fromAsset("../lambda"),
+        handler: "dist/index.lambdaWorker",
+        secrets: [mongoConnectionString],
+      },
+    );
+  }
+}
+```
+
+## lib/cdk-infrastructure.ts
+
+```typescript
+import {
+  JaypieInfrastructureStack,
+  JaypieWebDeploymentBucket,
+} from "@jaypie/constructs";
+
+export class InfrastructureStack extends JaypieInfrastructureStack {
+  constructor(scope, id, props = {}) {
+    super(scope, id, props);
+
+    new JaypieWebDeploymentBucket(this, "DeploymentBucket", {
+      // * host is not needed if CDK_ENV_WEB_SUBDOMAIN and CDK_ENV_WEB_HOSTED_ZONE or CDK_ENV_HOSTED_ZONE
+      // * zone is not needed if CDK_ENV_WEB_HOSTED_ZONE or CDK_ENV_HOSTED_ZONE
+    });
+  }
+}
+```
+
+## cdk.json
+
+```json
+{
+  "app": "npx ts-node --prefer-ts-exts bin/cdk.ts",
+  "watch": {
+    "include": [
+      "**"
+    ],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "**/*.d.ts",
+      "**/*.js",
+      "tsconfig.json",
+      "package*.json",
+      "yarn.lock",
+      "node_modules",
+      "test"
+    ]
+  }
+}
+```

package/prompts/Templates_Express_Subpackage.md

@@ -0,0 +1,183 @@
+---
+description: Template files for creating an Express on Lambda subpackage in a Jaypie monorepo
+---
+
+# Express Subpackage Templates
+
+Templates for creating an Express subpackage that runs on AWS Lambda in a Jaypie monorepo.
+
+## index.ts
+
+```typescript
+import serverlessExpress from "@codegenie/serverless-express";
+import app from "./src/app.js";
+
+export default serverlessExpress({ app });
+
+if (process.env.NODE_ENV === "development") {
+  app.listen(8080);
+}
+```
+
+## src/app.ts
+
+```typescript
+import { cors, echoRoute, EXPRESS, noContentRoute, notFoundRoute } from "jaypie";
+import express from "express";
+import resourceRouter from "./routes/resource.router.js";
+
+const app = express();
+
+// Built-in Jaypie routes
+app.get(EXPRESS.PATH.ROOT, noContentRoute);
+app.use("/_sy/echo", cors(), echoRoute);
+
+// Application routes
+app.use(/^\/resource$/, cors(), resourceRouter);
+app.use("/resource/", cors(), resourceRouter);
+
+// Catch-all
+app.all(EXPRESS.PATH.ANY, notFoundRoute);
+
+export default app;
+```
+
+## src/handler.config.ts
+
+```typescript
+import { force } from "jaypie";
+
+interface HandlerConfigOptions {
+  locals?: Record<string, any>;
+  setup?: Array<() => void | Promise<void>>;
+  teardown?: Array<() => void | Promise<void>>;
+  validate?: Array<() => boolean | Promise<boolean>>;
+}
+
+interface HandlerConfig {
+  name: string;
+  locals: Record<string, any>;
+  setup: Array<() => void | Promise<void>>;
+  teardown: Array<() => void | Promise<void>>;
+  validate: Array<() => boolean | Promise<boolean>>;
+}
+
+const handlerConfig = (
+  nameOrConfig: string | (HandlerConfig & { name: string }),
+  options: HandlerConfigOptions = {}
+): HandlerConfig => {
+  let name: string;
+  let locals: Record<string, any>;
+  let setup: Array<() => void | Promise<void>>;
+  let teardown: Array<() => void | Promise<void>>;
+  let validate: Array<() => boolean | Promise<boolean>>;
+
+  if (typeof nameOrConfig === "object") {
+    ({ name, locals = {}, setup = [], teardown = [], validate = [] } = nameOrConfig);
+  } else {
+    name = nameOrConfig;
+    ({ locals = {}, setup = [], teardown = [], validate = [] } = options);
+  }
+
+  return {
+    name,
+    locals: { ...force.object(locals) },
+    setup: [...force.array(setup)],
+    teardown: [...force.array(teardown)],
+    validate: [...force.array(validate)],
+  };
+};
+
+export default handlerConfig;
+```
+
+## src/routes/resource.router.ts
+
+```typescript
+import express from "express";
+import { EXPRESS } from "jaypie";
+import resourceGetRoute from "./resource/resourceGet.route.js";
+
+const router = express.Router();
+router.use(express.json({ strict: false }));
+
+// Single example route
+router.get(EXPRESS.PATH.ROOT, resourceGetRoute);
+
+export default router;
+```
+
+## src/routes/resource/resourceGet.route.ts
+
+```typescript
+import { expressHandler } from "jaypie";
+import type { Request } from "express";
+import handlerConfig from "../../handler.config.js";
+
+interface ResourceGetResponse {
+  message: string;
+  query: Record<string, any>;
+  timestamp: string;
+}
+
+export default expressHandler(
+  handlerConfig("resourceGet"),
+  async (req: Request): Promise<ResourceGetResponse> => {
+    const { query } = req;
+
+    return {
+      message: "Resource endpoint",
+      query,
+      timestamp: new Date().toISOString(),
+    };
+  }
+);
+```
+
+## src/routes/resource/__tests__/resourceGet.route.spec.ts
+
+```typescript
+import { describe, expect, it } from "vitest";
+import resourceGet from "../resourceGet.route.js";
+
+describe("Resource Get Route", () => {
+  it("returns resource data", async () => {
+    const mockRequest = {
+      query: { search: "test" },
+      locals: {},
+    } as any;
+
+    const response = await resourceGet(mockRequest);
+
+    expect(response.message).toBe("Resource endpoint");
+    expect(response.query).toEqual({ search: "test" });
+    expect(response.timestamp).toBeDefined();
+  });
+
+  it("handles empty query", async () => {
+    const mockRequest = {
+      query: {},
+      locals: {},
+    } as any;
+
+    const response = await resourceGet(mockRequest);
+
+    expect(response.message).toBe("Resource endpoint");
+    expect(response.query).toEqual({});
+  });
+});
+```
+
+## src/types/express.ts
+
+```typescript
+declare global {
+  namespace Express {
+    interface Request {
+      locals?: Record<string, any>;
+    }
+  }
+}
+
+export {};
+```

package/prompts/Templates_Project_Monorepo.md

@@ -0,0 +1,326 @@
+---
+description: Configuration examples for creating a monorepo using Jaypie conventions
+---
+
+# Project Monorepo Configuration Examples
+
+Configuration examples for creating a monorepo project following Jaypie conventions. These examples show the configuration files used in the Jaypie monorepo itself.
+
+## .gitignore
+
+Example based on Jaypie monorepo:
+
+```
+.jaypie
+
+cdk.out
+
+.DS_Store
+node_modules
+dist
+
+# Generated repomix files
+/prompts/context
+
+# local env files
+.aider*
+.env
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Editor directories and files
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+**/.claude/settings.local.json
+*.tsbuildinfo
+```
+
+## .vscode/settings.json
+
+Add project-specific words to spell checker. Example from Jaypie:
+
+```json
+{
+  "cSpell.words": [
+    "autofix",
+    "datadoghq",
+    "esmodules",
+    "hygen",
+    "jaypie",
+    "repomix",
+    "rollup",
+    "supertest",
+    "testkit",
+    "vite",
+    "vitest"
+  ]
+}
+```
+
+## eslint.config.mjs
+
+```javascript
+export { default as default } from "@jaypie/eslint";
+```
+
+## package.json
+
+Jaypie uses Lerna to run commands across all packages. Individual packages can be targeted using npm workspaces.
+
+```json
+{
+  "name": "@project-org/project-name",
+  "version": "0.0.1",
+  "type": "module",
+  "private": true,
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "build": "lerna run build",
+    "clean": "rimraf ./packages/*/dist",
+    "format": "npm run format:package && npm run format:lint",
+    "format:lint": "eslint --fix --quiet .",
+    "format:package": "sort-package-json ./package.json ./packages/*/package.json",
+    "lint": "eslint --quiet .",
+    "test": "vitest run",
+    "typecheck": "npm run typecheck --workspaces"
+  },
+  "devDependencies": {
+    "@jaypie/eslint": "^1.1.0",
+    "@jaypie/testkit": "^1.1.0",
+    "eslint": "^9.13.0",
+    "lerna": "^9.0.0",
+    "prettier": "^3.3.3",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.24.0",
+    "sort-package-json": "^3.2.0",
+    "vitest": "^3.0.5"
+  }
+}
+```
+
+Notes:
+- Use `lerna run build` to build all packages in dependency order
+- Use `npm run build --workspace packages/<package>` to build a single package
+- Install dependencies with `npm install <package> -w packages/<workspace>`
+
+## lerna.json
+
+```json
+{
+  "$schema": "node_modules/lerna/schemas/lerna-schema.json",
+  "version": "independent"
+}
+```
+
+## vitest.config.ts
+
+Jaypie uses an explicit project list rather than a glob pattern:
+
+```typescript
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    projects: [
+      "packages/errors",
+      "packages/core",
+      // ... list each package explicitly
+    ],
+  },
+});
+```
+
+Note: Use explicit package paths instead of `packages/*` to have better control over test execution order.
+
+## Package-Level tsconfig.json
+
+Each TypeScript package needs its own `tsconfig.json`. Example from `@jaypie/errors`:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+```
+
+## Package-Level rollup.config
+
+### TypeScript Package (Dual ESM/CJS)
+
+For TypeScript packages that need both ESM and CommonJS builds (`@jaypie/errors` pattern):
+
+```javascript
+import typescript from "@rollup/plugin-typescript";
+
+export default [
+  // ES modules version
+  {
+    input: "src/index.ts",
+    output: {
+      dir: "dist/esm",
+      format: "es",
+      sourcemap: true,
+    },
+    plugins: [
+      typescript({
+        tsconfig: "./tsconfig.json",
+        declaration: true,
+        outDir: "dist/esm",
+      }),
+    ],
+    external: [],
+  },
+  // CommonJS version
+  {
+    input: "src/index.ts",
+    output: {
+      dir: "dist/cjs",
+      format: "cjs",
+      sourcemap: true,
+      exports: "named",
+      entryFileNames: "[name].cjs",
+    },
+    plugins: [
+      typescript({
+        tsconfig: "./tsconfig.json",
+        declaration: true,
+        outDir: "dist/cjs",
+      }),
+    ],
+    external: [],
+  },
+];
+```
+
+Package.json exports for this pattern:
+
+```json
+{
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts"
+}
+```
+
+### JavaScript Package (ESM with CJS fallback)
+
+For JavaScript packages (`@jaypie/core` pattern):
+
+```javascript
+import autoExternal from "rollup-plugin-auto-external";
+import commonjs from "@rollup/plugin-commonjs";
+import resolve from "@rollup/plugin-node-resolve";
+
+export default {
+  input: "src/index.js",
+  output: [
+    {
+      file: "dist/package-name.cjs",
+      format: "cjs",
+    },
+    {
+      file: "dist/package-name.esm.js",
+      format: "esm",
+    },
+  ],
+  plugins: [
+    autoExternal(),
+    resolve(),
+    commonjs(),
+  ],
+};
+```
+
+## Package-Level package.json
+
+Example from `@jaypie/express`:
+
+```json
+{
+  "name": "@jaypie/express",
+  "version": "1.1.18",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/finlaysonstudio/jaypie"
+  },
+  "license": "MIT",
+  "author": "Finlayson Studio",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rollup --config",
+    "format": "npm run format:package && npm run format:lint",
+    "format:lint": "eslint --fix .",
+    "format:package": "sort-package-json ./package.json",
+    "lint": "eslint .",
+    "test": "vitest run .",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
+```
+
+Key points:
+- Use `"type": "module"` for ESM
+- Include only `dist` in published package via `files` field
+- Set `publishConfig.access` to "public" for npm publishing
+- Scripts use local paths (`.`) not workspace patterns
+
+## Key Differences from Template
+
+The Jaypie monorepo does NOT use:
+- Root-level `tsconfig.base.json` or `tsconfig.json` with project references
+- `vitest.workspace.js` with glob patterns
+- `npm run build --workspaces` (uses `lerna run build` instead)
+
+The Jaypie monorepo DOES use:
+- Individual package-level `tsconfig.json` files
+- Explicit vitest project list in root `vitest.config.ts`
+- Lerna for running commands across packages in dependency order
+- npm workspaces for installing dependencies and running individual package commands

package/prompts/Templates_Project_Subpackage.md

@@ -0,0 +1,93 @@
+---
+description: Template files for creating a new subpackage within a Jaypie monorepo
+---
+
+# Project Subpackage Templates
+
+Templates for creating a new subpackage within a Jaypie monorepo.
+
+## package.json
+
+```json
+{
+  "name": "@project-org/project-name",
+  "version": "0.0.1",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "build": "vite build",
+    "clean": "rimraf dist",
+    "format": "eslint --fix",
+    "format:package": "sort-package-json",
+    "lint": "eslint",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "typecheck": "tsc --noEmit"
+  }
+}
+```
+
+## tsconfig.json
+
+```json
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": [
+    "src"
+  ],
+  "references": []
+}
+```
+
+## vite.config.ts
+
+```typescript
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+import { resolve } from "path";
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: resolve(__dirname, "src/index.ts"),
+      formats: ["es"],
+      fileName: "index",
+    },
+    rollupOptions: {
+      external: ["jaypie"],
+    },
+  },
+  plugins: [
+    dts({
+      exclude: ["**/*.spec.ts"],
+    }),
+  ],
+});
+```
+
+## vitest.config.ts
+
+```typescript
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  test: {
+    setupFiles: ["./vitest.setup.ts"],
+  },
+});
+```
+
+## vitest.setup.ts
+
+```typescript
+import { matchers as jaypieMatchers } from "@jaypie/testkit";
+import * as extendedMatchers from "jest-extended";
+import { expect } from "vitest";
+
+expect.extend(extendedMatchers);
+expect.extend(jaypieMatchers);
+```