@jaypie/mcp 0.1.9 → 0.2.0

package/prompts/Jaypie_Init_Express_on_Lambda.md

@@ -1,68 +1,78 @@
 ---
 trigger: model_decision
-description: When asked to create a new workspace or subpackage for express, usually packages/express, to run as serverless Lambdas behind API Gateway
+description: Create a new Express application subpackage that runs as a serverless Lambda behind API Gateway using @jaypie/express utilities
 ---
 
-# Jaypie Initialize Express on Lambda Subpackage
+# Jaypie Initialize Express Application on Lambda
+
+Create an Express application subpackage that uses @jaypie/express to run as a serverless Lambda behind API Gateway. This prompt is for creating **application packages** (like packages/api or packages/backend), not the @jaypie/express library itself.
 
 ## Process
 
 1. Follow Jaypie_Init_Project_Subpackage.md:
-   * Use @project-org/express in packages/express
+   * Choose an appropriate package name (e.g., @project-org/api, @project-org/backend)
+   * Use packages/<package-name> for the directory (e.g., packages/api)
    * This creates the basic subpackage structure with package.json, tsconfig.json, and vitest config files
 
-2. Copy Express-specific template files:
-   * Copy `prompts/templates/express-subpackage/index.ts` to `packages/express/index.ts`
-   * Copy `prompts/templates/express-subpackage/src/app.ts` to `packages/express/src/app.ts`
-   * Copy `prompts/templates/express-subpackage/src/handler.config.ts` to `packages/express/src/handler.config.ts`
-   * Copy `prompts/templates/express-subpackage/src/routes/resource.router.ts` to `packages/express/src/routes/resource.router.ts`
-   * Copy `prompts/templates/express-subpackage/src/routes/resource/resourceGet.route.ts` to `packages/express/src/routes/resource/resourceGet.route.ts`
-   * Copy `prompts/templates/express-subpackage/src/routes/resource/__tests__/resourceGet.route.spec.ts` to `packages/express/src/routes/resource/__tests__/resourceGet.route.spec.ts`
-   * Copy `prompts/templates/express-subpackage/src/types/express.ts` to `packages/express/src/types/express.ts`
+2. Create Express application files using Templates_Express_Subpackage.md:
+   * Create `packages/<package-name>/index.ts` using the index.ts template
+   * Create `packages/<package-name>/src/app.ts` using the app.ts template
+   * Create `packages/<package-name>/src/handler.config.ts` using the handler.config.ts template
+   * Create `packages/<package-name>/src/routes/resource.router.ts` using the resource.router.ts template
+   * Create `packages/<package-name>/src/routes/resource/resourceGet.route.ts` using the resourceGet.route.ts template
+   * Create `packages/<package-name>/src/routes/resource/__tests__/resourceGet.route.spec.ts` using the test template
+   * Create `packages/<package-name>/src/types/express.ts` using the express types template
+   * All templates are documented in Templates_Express_Subpackage.md
 
 3. Update package.json scripts:
-   * Modify the existing scripts section to include:
+   * Add these scripts to the package.json:
      * `"dev": "tsx watch index.ts"`
      * `"start": "node dist/index.js"`
      * `"build": "tsc"`
-   * Run `npm run format:package`
+   * Keep existing scripts from the template (test, lint, typecheck, format)
+   * Run `npm --workspace ./packages/<package-name> run format:package`
 
 4. Install dependencies:
-   * `npm --workspace ./packages/express install jaypie express @codegenie/serverless-express`
-   * `npm --workspace ./packages/express install --save-dev @types/express @types/cors`
-   * Always run `npm install`, never update package.json with dependencies from memory
+   * `npm --workspace ./packages/<package-name> install jaypie express @codegenie/serverless-express`
+   * `npm --workspace ./packages/<package-name> install --save-dev @types/express @types/cors tsx`
+   * Always use npm install commands; never manually edit package.json dependencies
 
 5. Update TypeScript configuration:
-   * Update packages/express/tsconfig.json to include index.ts in the include array: `"include": ["src/**/*", "index.ts"]`
+   * Edit packages/<package-name>/tsconfig.json to include index.ts in the include array
+   * Change include to: `"include": ["src/**/*", "index.ts"]`
    * Change exclude to: `"exclude": ["node_modules", "dist", "**/*.spec.ts"]`
-   * Test the build
-   * Ensure dist/ is in gitignore
+   * Test the build with `npm --workspace ./packages/<package-name> run build`
+   * Verify dist/ is in root .gitignore (it should already be there)
 
 6. Update the top-level package.json:
-   * Add `"dev:express": "npm --workspace packages/express run dev"` and `"start:express": "npm --workspace packages/express run start"`
-   * If there is no stand-alone `dev` or `start`, create a `dev` running `dev:express` and `start` running `start:express`
-   * If `dev` or `start` exist, add calls to express if it fits the goal of the current commands
+   * Add workspace-specific dev and start scripts
+   * Add `"dev:<package-name>": "npm --workspace packages/<package-name> run dev"`
+   * Add `"start:<package-name>": "npm --workspace packages/<package-name> run start"`
+   * If there is no standalone `dev` or `start` script, create them referencing the new package
+   * If `dev` or `start` scripts already exist, consider whether to update them based on project needs
 
 ## Pattern
 
 - TypeScript with ES modules (`"type": "module"`)
 - Handler pattern: configuration → lifecycle → processing → response
-- Optional `handlerConfig` for shared configuration and lifecycle management
-- Clean separation of concerns with middleware patterns
-- Lambda-optimized Express configuration
+- Use `handlerConfig` helper for shared configuration and lifecycle management
+- Separation of concerns: routers, route handlers, and middleware
+- Lambda-optimized Express configuration using @codegenie/serverless-express
+- Development mode: Express listens on port 8080 when NODE_ENV=development
 
 ## Structure
 
 ```
-express/
+<package-name>/
 ├── package.json
 ├── tsconfig.json
-├── vitest.config.ts
-├── vitest.setup.ts
-├── index.ts
+├── vite.config.ts           # From template
+├── vitest.config.ts         # From template
+├── vitest.setup.ts          # From template
+├── index.ts                 # Lambda handler entry point
 ├── src/
-│   ├── app.ts
-│   ├── handler.config.ts
+│   ├── app.ts              # Express app configuration
+│   ├── handler.config.ts   # Shared handler configuration helper
 │   ├── routes/
 │   │   ├── resource.router.ts
 │   │   └── resource/
@@ -70,18 +80,36 @@ express/
 │   │       └── __tests__/
 │   │           └── resourceGet.route.spec.ts
 │   └── types/
-│       └── express.ts
-└── dist/
+│       └── express.ts      # Express type augmentation for req.locals
+└── dist/                   # Generated by tsc
 ```
 
 ## Local Development
 
-### Listening on Port 8080
+The index.ts template checks `process.env.NODE_ENV === "development"` to enable local development mode. In this mode, Express listens on port 8080 (port 3000 is typically reserved for frontend applications).
+
+Start local development with:
+```bash
+npm run dev:<package-name>
+```
 
-A local entrypoint, usually index.ts, may check `process.env.NODE_ENV === "development"` and be allowed to listen on port 8080 (preserving 3000 for front ends).
-`npm run dev:express` should be configured to initialize this mode locally.
+This runs `tsx watch index.ts`, which:
+- Sets up the Express app
+- Listens on port 8080
+- Auto-reloads on file changes
+- Does not invoke serverless-express wrapper
 
 ## Version Compatibility
 
-Jaypie uses Express 4.
-There is no immediately planned upgrade to Express 5.
+- Express: 4.x (Express 5 upgrade not planned)
+- Node: ES modules with TypeScript
+- @codegenie/serverless-express: 4.x
+- @types/express: Compatible with Express 4.x
+
+## Context Files
+
+Reference these files for additional guidance:
+- `Jaypie_Init_Project_Subpackage.md` - Subpackage initialization process
+- `Templates_Express_Subpackage.md` - Code templates for all files
+- `Jaypie_Express_Package.md` - Documentation on @jaypie/express features
+- `Jaypie_Core_Errors_and_Logging.md` - Error handling patterns

package/prompts/Jaypie_Init_Lambda_Package.md

@@ -25,10 +25,10 @@ Create AWS Lambda functions that integrate with Jaypie for event-driven processi
 ```
 packages/lambda/
 ├── package.json       # Define dependencies and scripts
-├── tsconfig.json      # TypeScript configuration 
-├── rollup.config.ts   # Bundle configuration
-├── vitest.config.ts   # Test configuration
-├── vitest.setup.ts    # Test setup and mocks
+├── tsconfig.json      # TypeScript configuration
+├── rollup.config.mjs  # Bundle configuration
+├── vite.config.js     # Test configuration
+├── testSetup.ts       # Test setup and matchers
 └── src/
     ├── index.ts       # Export handlers
     ├── worker.ts      # Lambda function implementation
@@ -43,21 +43,37 @@ packages/lambda/
   "name": "@yourorg/lambda",
   "version": "0.1.0",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "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",
+    "test": "vitest run .",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "jaypie": "^1.1.0"
+    "@jaypie/core": "^1.1.0",
+    "@jaypie/lambda": "^1.1.0"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^12.0.0",
     "@types/aws-lambda": "^8.10.0",
     "rollup": "^4.0.0",
+    "rollup-plugin-auto-external": "^2.0.0",
     "typescript": "^5.0.0"
   }
 }
@@ -74,107 +90,124 @@ packages/lambda/
     "declaration": true,
     "outDir": "./dist",
     "strict": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "src/__tests__"]
 }
 ```
 
 ### 4. Configure Rollup
 
-```typescript
+Create `rollup.config.mjs`:
+
+```javascript
+import autoExternal from "rollup-plugin-auto-external";
 import typescript from "@rollup/plugin-typescript";
-import type { RollupOptions } from "rollup";
 
-const config: RollupOptions[] = [
+export default [
+  // ES modules version
   {
-    input: "src/worker.ts",
+    input: "src/index.ts",
     output: {
-      file: "dist/worker.js",
+      dir: "dist/esm",
       format: "es",
-      sourcemap: true
+      sourcemap: true,
     },
     plugins: [
+      autoExternal(),
       typescript({
-        exclude: ["**/__tests__/**/*"]
-      })
+        tsconfig: "./tsconfig.json",
+        declaration: true,
+        outDir: "dist/esm",
+      }),
     ],
-    external: ["jaypie"]
   },
+  // CommonJS version
   {
     input: "src/index.ts",
     output: {
-      file: "dist/index.js",
-      format: "es",
-      sourcemap: true
+      dir: "dist/cjs",
+      format: "cjs",
+      sourcemap: true,
+      exports: "named",
+      entryFileNames: "[name].cjs",
     },
     plugins: [
+      autoExternal(),
       typescript({
-        exclude: ["**/__tests__/**/*"]
-      })
+        tsconfig: "./tsconfig.json",
+        declaration: true,
+        outDir: "dist/cjs",
+      }),
     ],
-    external: ["jaypie"]
-  }
+  },
 ];
-
-export default config;
 ```
 
 ### 5. Setup Vitest
 
-```typescript
-// vitest.config.ts
+Create `vite.config.js`:
+
+```javascript
+/// <reference types="vitest" />
+
 import { defineConfig } from "vite";
 
 export default defineConfig({
   test: {
-    setupFiles: ["./vitest.setup.ts"]
-  }
+    setupFiles: ["./testSetup.ts"],
+  },
 });
+```
 
-// vitest.setup.ts
+Create `testSetup.ts`:
+
+```typescript
 import { matchers as jaypieMatchers } from "@jaypie/testkit";
 import * as extendedMatchers from "jest-extended";
-import { expect, vi } from "vitest";
+import { expect } from "vitest";
 
 expect.extend(extendedMatchers);
 expect.extend(jaypieMatchers);
-
-vi.mock("jaypie", async () => vi.importActual("@jaypie/testkit/mock"));
 ```
 
+Note: Do not mock `jaypie` in the setup file for lambda consumer packages. Mock in individual test files as needed.
+
 ### 6. Create Handler Implementation
 
 ```typescript
 // src/worker.ts
-import { lambdaHandler, log } from "jaypie";
-import type { Context } from "jaypie";
+import { log } from "@jaypie/core";
+import { lambdaHandler } from "@jaypie/lambda";
+import type { LambdaContext } from "@jaypie/lambda";
 
 export interface WorkerEvent {
   message?: string;
 }
 
 export const handler = lambdaHandler(
-  async (event: WorkerEvent, context: Context) => {
+  async (event: WorkerEvent, context?: LambdaContext) => {
     log.trace("worker: start");
-    
+
     const message = event?.message || "Hello, world!";
-    
+
     log.trace("worker: processing message", { message });
-    
+
     const response = {
       status: "success",
       message,
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     };
-    
+
     log.trace("worker: complete");
     return response;
   },
   {
-    name: "worker"
-  }
+    name: "worker",
+  },
 );
 ```
 
@@ -187,59 +220,145 @@ export { handler as workerHandler } from "./worker.js";
 
 ### 8. Write Tests
 
+Tests are organized in sections: Base Cases, Error Conditions, Security, Observability, Happy Paths, Features, Specific Scenarios. Omit sections that are not applicable.
+
 ```typescript
 // src/__tests__/worker.spec.ts
-import { vi, describe, it, expect, beforeEach } from "vitest";
-import { handler, WorkerEvent } from "../worker.js";
-import { log } from "jaypie";
-import type { Context } from "jaypie";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { log } from "@jaypie/core";
+import { restoreLog, spyLog } from "@jaypie/testkit";
+
+// Subject
+import { handler } from "../worker.js";
+import type { WorkerEvent } from "../worker.js";
+
+//
+//
+// Mock modules
+//
 
-vi.mock("jaypie", async () => vi.importActual("@jaypie/testkit/mock"));
+vi.mock("@jaypie/core", async () => {
+  const actual = await vi.importActual("@jaypie/core");
+  return {
+    ...actual,
+  };
+});
+
+//
+//
+// Mock environment
+//
+
+const DEFAULT_ENV = process.env;
+beforeEach(() => {
+  process.env = { ...process.env };
+  spyLog(log);
+});
+afterEach(() => {
+  process.env = DEFAULT_ENV;
+  vi.clearAllMocks();
+  restoreLog(log);
+});
+
+//
+//
+// Run tests
+//
 
 describe("worker Lambda handler", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
+  describe("Base Cases", () => {
+    it("Works", async () => {
+      const event: WorkerEvent = {};
+      const result = await handler(event);
+      expect(result).toBeDefined();
+    });
   });
 
-  it("returns success with provided message", async () => {
-    const event: WorkerEvent = {
-      message: "Test message"
-    };
-
-    const result = await handler(event, {} as Context);
-    
-    expect(result).toHaveProperty("status", "success");
-    expect(result).toHaveProperty("message", "Test message");
-    expect(result).toHaveProperty("timestamp");
+  describe("Observability", () => {
+    it("Does not log above trace", async () => {
+      const event: WorkerEvent = { message: "Test" };
+      await handler(event);
+      expect(log).not.toBeCalledAboveTrace();
+    });
   });
 
-  it("returns default message when none provided", async () => {
-    const event = {} as WorkerEvent;
+  describe("Happy Paths", () => {
+    it("Returns success with provided message", async () => {
+      const event: WorkerEvent = {
+        message: "Test message",
+      };
 
-    const result = await handler(event, {} as Context);
-    
-    expect(result).toHaveProperty("message", "Hello, world!");
-  });
+      const result = await handler(event);
 
-  it("logs trace for operations", async () => {
-    const event: WorkerEvent = {
-      message: "Test message"
-    };
+      expect(result).toHaveProperty("status", "success");
+      expect(result).toHaveProperty("message", "Test message");
+      expect(result).toHaveProperty("timestamp");
+    });
+
+    it("Returns default message when none provided", async () => {
+      const event: WorkerEvent = {};
 
-    await handler(event, {} as Context);
-    
-    expect(log.trace).toHaveBeenCalled();
-    expect(log).not.toBeCalledAboveTrace();
+      const result = await handler(event);
+
+      expect(result).toHaveProperty("message", "Hello, world!");
+    });
   });
 });
 ```
 
-### 9. Build and Deploy
+### 9. Build and Test
+
+Build, lint, typecheck, and test the package:
 
 ```bash
-# Build the Lambda package
-npm run build
+# Install dependencies (from monorepo root)
+npm install <package> -w packages/lambda
+
+# Lint and format
+npm run format -w packages/lambda
+
+# Type check
+npm run typecheck -w packages/lambda
+
+# Build the package
+npm run build -w packages/lambda
+
+# Run tests
+npm run test -w packages/lambda
+```
+
+### 10. Deploy
+
+Deploy using AWS CDK or other deployment tool. The Lambda handler will be referenced as "workerHandler" from the built package.
+
+## Important Notes
+
+### Import Patterns
+
+- Import `lambdaHandler` from `@jaypie/lambda`, not from `jaypie`
+- Import `log` from `@jaypie/core`, not from `jaypie`
+- Use `LambdaContext` type from `@jaypie/lambda`, not `Context` from `jaypie`
+- TypeScript files must use `.js` extension in relative imports (e.g., `from "./worker.js"`)
+
+### Test Structure
+
+- Tests are organized in 7 sections: Base Cases, Error Conditions, Security, Observability, Happy Paths, Features, Specific Scenarios
+- Omit sections that are not applicable
+- Use `spyLog` and `restoreLog` from `@jaypie/testkit` for logging tests
+- Use Jaypie matchers like `toBeCalledAboveTrace()` for observability tests
+- Mock `@jaypie/core` in test files, not in `testSetup.ts`
+
+### Build Configuration
+
+- Use `rollup-plugin-auto-external` to automatically exclude dependencies from bundles
+- Build both ESM and CommonJS formats for maximum compatibility
+- Use `vite.config.js` (not `vitest.config.ts`) for test configuration
+- Use `testSetup.ts` (not `vitest.setup.ts`) for test setup
+
+### Code Style
 
-# Deploy using AWS CDK or other deployment tool
-# The Lambda handler will be referenced as "workerHandler"
-```
+- Use double quotes, trailing commas, semicolons
+- Alphabetize imports and properties
+- Define constants for hard-coded values at file top
+- Never throw vanilla Error; use errors from `@jaypie/errors`

package/prompts/Jaypie_Init_Project_Subpackage.md

@@ -15,10 +15,11 @@ Create a subpackage within an existing monorepo project.
 
 ## Guidelines
 
-* Follow Jaypie_Project_Structure.md conventions
-* Subpackage names follow "@project-org/package-name" pattern
+* Follow Jaypie_Ideal_Project_Structure.md conventions
+* Subpackage names follow "@project-org/package-name" pattern (example: "@jaypie/errors")
 * Use `"version": "0.0.1"`, `"type": "module"`, and `"private": true`
 * Place packages in `packages/<package-name>/` directory
+* Build tool: Use Vite for new TypeScript packages (template uses Vite). Some older packages use Rollup.
 
 ## Process
 
@@ -30,12 +31,12 @@ Create a subpackage within an existing monorepo project.
    └── tsconfig.json
    ```
 
-2. Copy template files:
-   * Copy `prompts/templates/project-subpackage/package.json` to `packages/<package-name>/package.json`
-   * Copy `prompts/templates/project-subpackage/tsconfig.json` to `packages/<package-name>/tsconfig.json`
-   * Copy `prompts/templates/project-subpackage/vite.config.ts` to `packages/<package-name>/vite.config.ts`
-   * Copy `prompts/templates/project-subpackage/vitest.config.ts` to `packages/<package-name>/vitest.config.ts`
-   * Copy `prompts/templates/project-subpackage/vitest.setup.ts` to `packages/<package-name>/vitest.setup.ts`
+2. Create template files using Templates_Project_Subpackage.md:
+   * Create `packages/<package-name>/package.json` from template
+   * Create `packages/<package-name>/tsconfig.json` from template
+   * Create `packages/<package-name>/vite.config.ts` from template
+   * Create `packages/<package-name>/vitest.config.ts` from template
+   * Create `packages/<package-name>/vitest.setup.ts` from template
 
 3. Update package.json:
    * Edit name from "@project-org/project-name" to "@project-org/<package-name>"
@@ -43,28 +44,22 @@ Create a subpackage within an existing monorepo project.
 
 4. Create basic src structure:
    * Create `src/index.ts` with basic export
-   * Create `src/index.spec.ts` with basic test
+   * Create `src/__tests__/` directory for tests
+   * Create `src/__tests__/index.spec.ts` with basic test (use sections: Base Cases, Happy Paths)
 
 5. Update workspace configuration:
-   * Update `references` in root `tsconfig.json`
-   * Update `paths` in root `tsconfig.base.json`
-   * Add package path to root `vitest.workspace.js`
-   * Remove wildcards from `vitest.workspace.js` if present
+   * Add package path to `test.projects` array in root `vitest.config.ts` (format: "packages/<package-name>")
+   * Ensure packages are listed explicitly (no wildcards)
+   * Example: Add "packages/new-package" to the projects array
 
-6. Install requested software:
-   * Always use `npm --workspace ./packages/new-package install`
-   * Never edit `package.json` from memory
+6. Install dependencies for the new package:
+   * Use `npm install <package-name> --workspace ./packages/<package-name>` to add dependencies
+   * Use `npm install <package-name> --workspace ./packages/<package-name> --save-dev` for dev dependencies
+   * Never manually edit `package.json` - always use npm commands to maintain package-lock.json
 
 ## Context
 
-prompts/prompts/Jaypie_Project_Structure.md
-prompts/templates/project-monorepo/tsconfig.base.json
-prompts/templates/project-subpackage/package.json
-prompts/templates/project-subpackage/tsconfig.json
-prompts/templates/project-subpackage/vite.config.ts
-prompts/templates/project-subpackage/vitest.config.ts
-prompts/templates/project-subpackage/vitest.setup.ts
+prompts/Jaypie_Ideal_Project_Structure.md
+prompts/Templates_Project_Subpackage.md
 package.json
-tsconfig.json
-tsconfig.base.json
-vitest.workspace.js
+vitest.config.ts

package/prompts/Jaypie_Legacy_Patterns.md

@@ -4,6 +4,10 @@ description: Old conventions repositories should update and the new conventions
 
 # Jaypie Legacy Patterns
 
+## Mongoose
+
+Use MongoDB directly or something else
+
 ## TypeScript, Not Vanilla JavaScript
 
 ## Vite for Builds