@jaypie/mcp 0.3.2 → 0.4.0

package/prompts/Jaypie_Init_Express_on_Lambda.md

@@ -1,115 +0,0 @@
----
-trigger: model_decision
-description: Create a new Express application subpackage that runs as a serverless Lambda behind API Gateway using @jaypie/express utilities
----
-
-# 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:
-   * 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. 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:
-   * Add these scripts to the package.json:
-     * `"dev": "tsx watch index.ts"`
-     * `"start": "node dist/index.js"`
-     * `"build": "tsc"`
-   * 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/<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:
-   * 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 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 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
-- 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
-
-```
-<package-name>/
-├── package.json
-├── tsconfig.json
-├── vite.config.ts           # From template
-├── vitest.config.ts         # From template
-├── vitest.setup.ts          # From template
-├── index.ts                 # Lambda handler entry point
-├── src/
-│   ├── app.ts              # Express app configuration
-│   ├── handler.config.ts   # Shared handler configuration helper
-│   ├── routes/
-│   │   ├── resource.router.ts
-│   │   └── resource/
-│   │       ├── resourceGet.route.ts
-│   │       └── __tests__/
-│   │           └── resourceGet.route.spec.ts
-│   └── types/
-│       └── express.ts      # Express type augmentation for req.locals
-└── dist/                   # Generated by tsc
-```
-
-## Local Development
-
-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>
-```
-
-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
-
-- 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_Jaypie_CDK_Package.md

@@ -1,35 +0,0 @@
----
-trigger: model_decision
-description: When asked to create a new workspace or subpackage for cdk, usually packages/cdk
----
-
-# Jaypie Initialize CDK Subpackage
-
-## Process
-
-1. Follow Jaypie_Init_Project_Subpackage.md:
-   * Use @project-org/cdk in packages/cdk
-   * Skip the src structure
-
-2. Copy template files:
-   * Copy `prompts/templates/cdk-subpackage/bin/cdk.ts` to `packages/cdk/bin/cdk.ts`
-   * Copy `prompts/templates/cdk-subpackage/lib/cdk-app.ts` to `packages/cdk/lib/cdk-app.ts`
-   * Copy `prompts/templates/cdk-subpackage/lib/cdk-infrastructure.ts` to `packages/cdk/lib/cdk-infrastructure.ts`
-   * Copy `prompts/templates/cdk-subpackage/cdk.json` to `packages/cdk/cdk.json`
-
-3. Update package.json:
-   * Add `"bin": {"cdk": "dist/cdk.js"}`
-   * In `scripts`,
-       * Make `"clean": "rimfaf cdk.out",`
-       * Add `"cdk": "cdk",`
-   * Run `npm run format:package`
-
-4. Install dependencies:
-   * `npm --workspace ./packages/cdk install @jaypie/constructs aws-cdk-lib constructs`
-   * `npm --workspace ./packages/cdk install --save-dev aws-cdk`
-   * Always run `npm install`, never update package.json with dependencies from memory
-
-5. Update TypeScript build:
-   * Update packages/cdk/tsconfig.json and packages/cdk/vite.config.ts to build from bin and lib while creating dist/cdk.js
-   * Test the build
-   * Make sure `cdk.out` is in gitignore

package/prompts/Jaypie_Init_Lambda_Package.md

@@ -1,505 +0,0 @@
----
-trigger: model_decision
-description: When asked to create a new workspace or subpackage for lambdas
----
-
-# Jaypie Lambda Package
-
-Lambda package structure for AWS Lambda functions using Jaypie.
-
-## Goal
-
-Create AWS Lambda functions that integrate with Jaypie for event-driven processing.
-
-## Guidelines
-
-- Uses TypeScript with ES modules
-- Leverages Jaypie's lambdaHandler wrapper for setup/teardown
-- Built with Rollup for optimized deployment packages
-- Tests with Vitest and Jaypie testkit
-
-## Process
-
-### 1. Setup Package Structure
-
-```
-packages/lambda/
-├── package.json       # Define dependencies and scripts
-├── 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
-    └── __tests__/     # Test files
-        └── worker.spec.ts
-```
-
-### 2. Configure package.json
-
-```json
-{
-  "name": "@yourorg/lambda",
-  "version": "0.1.0",
-  "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"
-  },
-  "dependencies": {
-    "@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"
-  }
-}
-```
-
-### 3. Configure TypeScript
-
-```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", "src/__tests__"]
-}
-```
-
-### 4. Configure Rollup
-
-Create `rollup.config.mjs`:
-
-```javascript
-import autoExternal from "rollup-plugin-auto-external";
-import typescript from "@rollup/plugin-typescript";
-
-export default [
-  // ES modules version
-  {
-    input: "src/index.ts",
-    output: {
-      dir: "dist/esm",
-      format: "es",
-      sourcemap: true,
-    },
-    plugins: [
-      autoExternal(),
-      typescript({
-        tsconfig: "./tsconfig.json",
-        declaration: true,
-        outDir: "dist/esm",
-      }),
-    ],
-  },
-  // CommonJS version
-  {
-    input: "src/index.ts",
-    output: {
-      dir: "dist/cjs",
-      format: "cjs",
-      sourcemap: true,
-      exports: "named",
-      entryFileNames: "[name].cjs",
-    },
-    plugins: [
-      autoExternal(),
-      typescript({
-        tsconfig: "./tsconfig.json",
-        declaration: true,
-        outDir: "dist/cjs",
-      }),
-    ],
-  },
-];
-```
-
-### 5. Setup Vitest
-
-Create `vite.config.js`:
-
-```javascript
-/// <reference types="vitest" />
-
-import { defineConfig } from "vite";
-
-export default defineConfig({
-  test: {
-    setupFiles: ["./testSetup.ts"],
-  },
-});
-```
-
-Create `testSetup.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);
-```
-
-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 { 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?: 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(),
-    };
-
-    log.trace("worker: complete");
-    return response;
-  },
-  {
-    name: "worker",
-  },
-);
-```
-
-### 7. Export Handler
-
-```typescript
-// src/index.ts
-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 { 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/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", () => {
-  describe("Base Cases", () => {
-    it("Works", async () => {
-      const event: WorkerEvent = {};
-      const result = await handler(event);
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe("Observability", () => {
-    it("Does not log above trace", async () => {
-      const event: WorkerEvent = { message: "Test" };
-      await handler(event);
-      expect(log).not.toBeCalledAboveTrace();
-    });
-  });
-
-  describe("Happy Paths", () => {
-    it("Returns success with provided message", async () => {
-      const event: WorkerEvent = {
-        message: "Test message",
-      };
-
-      const result = await handler(event);
-
-      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 = {};
-
-      const result = await handler(event);
-
-      expect(result).toHaveProperty("message", "Hello, world!");
-    });
-  });
-});
-```
-
-### 9. Build and Test
-
-Build, lint, typecheck, and test the package:
-
-```bash
-# 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
-
-- 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`
-
-## Streaming Lambda Functions
-
-Use `lambdaStreamHandler` for AWS Lambda Response Streaming. This enables real-time streaming responses for LLM interactions, large file processing, and SSE endpoints.
-
-### Lambda Streaming Setup
-
-Create a streaming Lambda handler with `awslambda.streamifyResponse`:
-
-```typescript
-// src/streamWorker.ts
-import { log } from "@jaypie/core";
-import { lambdaStreamHandler, createLambdaStream, Llm } from "jaypie";
-import type { StreamHandlerContext } from "@jaypie/lambda";
-
-export interface StreamWorkerEvent {
-  prompt?: string;
-}
-
-const streamWorker = lambdaStreamHandler(
-  async (event: StreamWorkerEvent, context: StreamHandlerContext) => {
-    log.trace("streamWorker: start");
-
-    const llm = new Llm("anthropic");
-    const stream = llm.stream(event.prompt || "Hello");
-
-    // createLambdaStream pipes LLM chunks as SSE events
-    await createLambdaStream(stream, context.responseStream);
-
-    log.trace("streamWorker: complete");
-  },
-  {
-    name: "streamWorker",
-    contentType: "text/event-stream",
-  }
-);
-
-// Wrap with AWS streamifyResponse
-declare const awslambda: { streamifyResponse: <T>(handler: T) => T };
-export const handler = awslambda.streamifyResponse(streamWorker);
-```
-
-### Manual Stream Writing
-
-Write directly to the response stream for custom SSE events:
-
-```typescript
-import { lambdaStreamHandler } from "jaypie";
-import type { StreamHandlerContext } from "@jaypie/lambda";
-
-const manualStreamHandler = lambdaStreamHandler(
-  async (event: unknown, context: StreamHandlerContext) => {
-    const { responseStream } = context;
-
-    // Write SSE events directly
-    responseStream.write("event: start\ndata: {\"status\": \"processing\"}\n\n");
-
-    // Process data in chunks
-    for (const item of items) {
-      const result = await process(item);
-      responseStream.write(`event: data\ndata: ${JSON.stringify(result)}\n\n`);
-    }
-
-    responseStream.write("event: done\ndata: {\"status\": \"complete\"}\n\n");
-    // Handler automatically calls responseStream.end()
-  },
-  {
-    name: "manualStream",
-  }
-);
-```
-
-### Stream Handler Options
-
-```typescript
-import type { LambdaStreamHandlerOptions } from "@jaypie/lambda";
-
-const options: LambdaStreamHandlerOptions = {
-  name: "myStreamHandler",          // Handler name for logging
-  contentType: "text/event-stream", // Response content type (default)
-  chaos: "low",                     // Chaos testing level
-  secrets: ["API_KEY"],             // AWS secrets to load into process.env
-  setup: [],                        // Setup function(s)
-  teardown: [],                     // Teardown function(s)
-  validate: [],                     // Validation function(s)
-  throw: false,                     // Re-throw errors instead of SSE error
-  unavailable: false,               // Return 503 if true
-};
-```
-
-### Stream Handler Types
-
-```typescript
-import type {
-  LambdaStreamHandlerOptions,
-  StreamHandlerContext,
-  ResponseStream,
-  AwsStreamingHandler,
-} from "@jaypie/lambda";
-```
-
-### CDK Configuration for Streaming
-
-Enable Lambda Response Streaming via Function URL in CDK:
-
-```typescript
-import { JaypieLambda } from "@jaypie/constructs";
-import { FunctionUrlAuthType, InvokeMode } from "aws-cdk-lib/aws-lambda";
-
-const streamingLambda = new JaypieLambda(this, "StreamingFunction", {
-  code: "dist",
-  handler: "streamWorker.handler",
-  timeout: Duration.minutes(5),
-});
-
-// Add Function URL with streaming enabled
-streamingLambda.addFunctionUrl({
-  authType: FunctionUrlAuthType.NONE, // or AWS_IAM for auth
-  invokeMode: InvokeMode.RESPONSE_STREAM,
-});
-
-// Or use JaypieDistribution with streaming: true for CloudFront integration
-new JaypieDistribution(this, "Distribution", {
-  handler: streamingLambda,
-  streaming: true,
-  host: "api.example.com",
-  zone: "example.com",
-});
-```
-
-### Error Handling in Streams
-
-Errors are formatted as SSE error events:
-
-```typescript
-// Jaypie errors written as:
-// event: error
-// data: {"errors":[{"status":500,"title":"Internal Error"}]}
-```
-
-Set `throw: true` to re-throw errors instead of writing to stream.

package/prompts/Jaypie_Init_Monorepo_Project.md

@@ -1,44 +0,0 @@
----
-description: Monorepo setup using Jaypie conventions and utilities
----
-
-# Jaypie Initialize Monorepo Project
-
-Monorepo setup using Jaypie conventions and utilities
-
-## Goal
-
-* Jaypie project opinions and tooling
-* ESLint 9+ flat config with @jaypie/eslint
-* NPM with Workspaces ("monorepo")
-* TypeScript
-* Vite and Vitest
-
-## Guidelines
-
-* This guide should compliment Jaypie_Project_Structure.md. The two should not conflict. Raise any conflicts with the user.
-* Run `npm install` to get the latest version of all software and generate a package-lock.json. Do not hard-code package versions from memory.
-* If this is the very first commit, you should make it on main. This is the only time a commit should be made and pushed on main.
-
-## Process
-
-1. Copy all the files from `prompts/templates/project-monorepo/` to the root directory
-2. Edit name in "@project-org/project-name" based on user instruction or infer from the directory name
-3. Remove the sample paths from tsconfig.base.json
-4. Remove the sample references from tsconfig.json
-5. Install requisite packages
-
-```bash
-npm install --save-dev @jaypie/eslint @jaypie/testkit eslint rimraf sort-package-json tsx vite vite-plugin-dts vitest
-```
-
-## Context
-
-prompts/Jaypie_Ideal_Project_Structure.md
-prompts/templates/project-monorepo/gitignore (rename to .gitignore when copying)
-prompts/templates/project-monorepo/.vscode/settings.json
-prompts/templates/project-monorepo/eslint.config.mjs
-prompts/templates/project-monorepo/package.json
-prompts/templates/project-monorepo/tsconfig.base.json
-prompts/templates/project-monorepo/tsconfig.json
-prompts/templates/project-monorepo/vitest.workspace.js