@jaypie/mcp 0.1.10 → 0.2.1

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

package/prompts/Jaypie_Repokit.md

@@ -0,0 +1,103 @@
+---
+description: development utilities bundle for Jaypie repositories
+---
+
+# Jaypie Repokit
+
+Essential development utilities bundled for Jaypie repositories. Provides common tools needed for build scripts, development workflows, and repository maintenance.
+
+## Installation
+
+```sh
+npm install --save-dev @jaypie/repokit
+```
+
+## Exported Utilities
+
+### dotenv
+
+Re-exports everything from `dotenv` for environment variable management.
+
+```typescript
+import { config } from "@jaypie/repokit";
+
+config(); // Load .env file
+```
+
+### rimraf
+
+Re-exports `rimraf` for cross-platform file deletion.
+
+```typescript
+import { rimraf } from "@jaypie/repokit";
+
+await rimraf("./dist");
+```
+
+## CLI Tools (via npx)
+
+The package includes CLI tools as dependencies that can be run via npx or in package.json scripts:
+
+### env-cmd
+
+Run commands with environment variables from a file.
+
+```json
+{
+  "scripts": {
+    "start:dev": "env-cmd -f .env.development node server.js"
+  }
+}
+```
+
+### sort-package-json
+
+Sort package.json files for consistent formatting.
+
+```json
+{
+  "scripts": {
+    "format:package": "sort-package-json ./package.json"
+  }
+}
+```
+
+### tsx
+
+Run TypeScript files directly without compilation.
+
+```json
+{
+  "scripts": {
+    "bin:script": "tsx scripts/my-script.ts"
+  }
+}
+```
+
+## Common Usage Patterns
+
+### Build Scripts
+
+```json
+{
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "format:package": "sort-package-json ./package.json",
+    "bin:setup": "tsx scripts/setup.ts"
+  }
+}
+```
+
+### Environment Management
+
+```typescript
+// scripts/deploy.ts
+import { config } from "@jaypie/repokit";
+
+config({ path: ".env.production" });
+console.log(process.env.API_KEY);
+```
+
+## Why Use Repokit
+
+Instead of installing `dotenv`, `rimraf`, `env-cmd`, `sort-package-json`, and `tsx` individually in each package, install `@jaypie/repokit` once to get all essential development utilities. This ensures consistent versions across all Jaypie repositories.