@jaypie/mcp 0.2.9 → 0.2.12

package/dist/index.js

@@ -885,7 +885,7 @@ function listLlmProviders() {
     };
 }
 
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.9#f022ac30"
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.12#512ddebf"
     ;
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/mcp",
-  "version": "0.2.9",
+  "version": "0.2.12",
   "description": "Jaypie MCP",
   "repository": {
     "type": "git",

package/prompts/Jaypie_CDK_Constructs_and_Patterns.md

@@ -102,33 +102,27 @@ Preconfigured with API-optimized timeouts and role tags.
 
 ### Streaming Lambda Functions
 
-Use `JaypieStreamingLambda` for Express apps with AWS Lambda Web Adapter and streaming support:
+For streaming responses (SSE, real-time updates), use `createLambdaStreamHandler` from `@jaypie/express` with `JaypieDistribution`:
 
 ```typescript
-import { JaypieStreamingLambda, JaypieDistribution } from "@jaypie/constructs";
+import { JaypieExpressLambda, JaypieDistribution } from "@jaypie/constructs";
+import * as lambda from "aws-cdk-lib/aws-lambda";
 
-// Create streaming Lambda with Web Adapter
-const streamingLambda = new JaypieStreamingLambda(this, "StreamingApi", {
+// Create Lambda (handler uses createLambdaStreamHandler internally)
+const streamingApi = new JaypieExpressLambda(this, "StreamingApi", {
   code: "dist/api",
-  handler: "run.sh",           // Shell script to start Express app
-  streaming: true,             // Enables RESPONSE_STREAM invoke mode
-  port: 8000,                  // Port your app listens on (default: 8000)
+  handler: "index.handler",
 });
 
-// CloudFront auto-detects invokeMode from JaypieStreamingLambda
+// Use with CloudFront and RESPONSE_STREAM invoke mode
 new JaypieDistribution(this, "Distribution", {
-  handler: streamingLambda,
+  handler: streamingApi,
+  invokeMode: lambda.InvokeMode.RESPONSE_STREAM,
   host: "api.example.com",
   zone: "example.com",
 });
 ```
 
-Features:
-- Automatically adds AWS Lambda Web Adapter layer (supports ARM64 and x86_64)
-- Sets `AWS_LAMBDA_EXEC_WRAPPER` and `AWS_LWA_INVOKE_MODE` environment variables
-- Exposes `invokeMode` property for auto-detection by `JaypieDistribution`
-- Use `streaming: false` for buffered mode (traditional Lambda behavior)
-
 For direct Function URL access (bypass CloudFront):
 ```typescript
 import { FunctionUrlAuthType, InvokeMode } from "aws-cdk-lib/aws-lambda";
@@ -147,7 +141,7 @@ const functionUrl = streamingLambda.addFunctionUrl({
 new cdk.CfnOutput(this, "StreamingUrl", { value: functionUrl.url });
 ```
 
-Note: API Gateway has a 29-second timeout limit. For longer streaming operations, use Function URLs or CloudFront with Lambda Function URLs.
+Note: Streaming requires Lambda Function URLs (not API Gateway). `JaypieDistribution` uses Function URLs by default.
 
 ### Stack Types
 
@@ -323,21 +317,22 @@ Common usage:
 
 ### DynamoDB Tables
 
-Use `JaypieDynamoDb` for single-table design with Jaypie GSI patterns:
+Use `JaypieDynamoDb` for single-table design with Jaypie patterns:
 ```typescript
 // Shorthand: tableName becomes "myApp", construct id is "JaypieDynamoDb-myApp"
 const table = new JaypieDynamoDb(this, "myApp");
 
-// No GSIs
-const table = new JaypieDynamoDb(this, "MyTable", {
-  globalSecondaryIndexes: false,
+// With standard Jaypie GSIs (indexScope, indexAlias, indexClass, indexType, indexXid)
+const tableWithIndexes = new JaypieDynamoDb(this, "myApp", {
+  indexes: JaypieDynamoDb.DEFAULT_INDEXES,
 });
 
-// Use only specific GSIs
-const table = new JaypieDynamoDb(this, "MyTable", {
-  globalSecondaryIndexes: [
-    JaypieDynamoDb.GlobalSecondaryIndex.Ou,
-    JaypieDynamoDb.GlobalSecondaryIndex.Type,
+// With custom indexes using IndexDefinition from @jaypie/fabric
+const customTable = new JaypieDynamoDb(this, "myApp", {
+  indexes: [
+    { pk: ["scope", "model"], sk: ["sequence"] },           // indexScopeModel
+    { pk: ["scope", "model", "type"], sparse: true },       // indexScopeModelType
+    { name: "byAlias", pk: ["alias"], sk: ["createdAt"] },  // custom name
   ],
 });
 
@@ -352,9 +347,9 @@ Features:
 - Default partition key: `model` (string), sort key: `id` (string)
 - PAY_PER_REQUEST billing mode by default
 - RETAIN removal policy in production, DESTROY otherwise
-- GSI options: `true`/omit = all five, `false` = none, array = specific GSIs
-- Static constants: `JaypieDynamoDb.GlobalSecondaryIndex.*` and `JaypieDynamoDb.GlobalSecondaryIndexes`
-- All GSIs use partition key (string) + `sequence` (number) sort key
+- No GSIs by default - use `indexes` prop to add them
+- `JaypieDynamoDb.DEFAULT_INDEXES` provides standard Jaypie GSIs from `@jaypie/fabric`
+- Uses `IndexDefinition` from `@jaypie/fabric` for GSI configuration
 - Implements `ITableV2` interface
 
 For single-table design patterns, key builders, and query utilities, see `Jaypie_DynamoDB_Package.md`.

package/prompts/Jaypie_DynamoDB_Package.md

@@ -21,21 +21,21 @@ All entities share a single DynamoDB table with:
 - **Primary Key**: `model` (partition) + `id` (sort)
 - **Five GSIs**: All use `sequence` as sort key for chronological ordering
 
-### Organizational Unit (OU)
+### Scope
 
-The `ou` field creates hierarchical relationships:
-- Root entities: `ou = "@"` (APEX constant)
-- Child entities: `ou = "{parent.model}#{parent.id}"`
+The `scope` field creates hierarchical relationships:
+- Root entities: `scope = "@"` (APEX constant)
+- Child entities: `scope = "{parent.model}#{parent.id}"`
 
 ### GSI Pattern
 
 | GSI Name | Partition Key | Use Case |
 |----------|---------------|----------|
-| `indexOu` | `{ou}#{model}` | List all entities under a parent |
-| `indexAlias` | `{ou}#{model}#{alias}` | Human-friendly slug lookup |
-| `indexClass` | `{ou}#{model}#{class}` | Category filtering |
-| `indexType` | `{ou}#{model}#{type}` | Type filtering |
-| `indexXid` | `{ou}#{model}#{xid}` | External system ID lookup |
+| `indexScope` | `{scope}#{model}` | List all entities under a parent |
+| `indexAlias` | `{scope}#{model}#{alias}` | Human-friendly slug lookup |
+| `indexClass` | `{scope}#{model}#{class}` | Category filtering |
+| `indexType` | `{scope}#{model}#{type}` | Type filtering |
+| `indexXid` | `{scope}#{model}#{xid}` | External system ID lookup |
 
 ## Client Initialization
 
@@ -61,21 +61,21 @@ initClient({
 });
 ```
 
-## FabricEntity Interface
+## StorableEntity Interface
 
-All entities must implement `FabricEntity`:
+All entities must implement `StorableEntity`:
 
 ```typescript
-import type { FabricEntity } from "@jaypie/dynamodb";
+import type { StorableEntity } from "@jaypie/dynamodb";
 
-interface MyRecord extends FabricEntity {
+interface MyRecord extends StorableEntity {
   // Primary Key (required)
   model: string;      // e.g., "record"
   id: string;         // UUID
 
   // Required fields
   name: string;
-  ou: string;         // APEX or hierarchical
+  scope: string;      // APEX or hierarchical
   sequence: number;   // Date.now()
 
   // Timestamps (ISO 8601)
@@ -108,7 +108,7 @@ const record = await putEntity({
     model: "record",
     id: crypto.randomUUID(),
     name: "Daily Log",
-    ou: APEX,
+    scope: APEX,
     sequence: Date.now(),
     alias: "2026-01-07",    // Optional
     class: "memory",        // Optional
@@ -118,7 +118,7 @@ const record = await putEntity({
 });
 
 // Result includes auto-populated indexes:
-// indexOu: "@#record"
+// indexScope: "@#record"
 // indexAlias: "@#record#2026-01-07"
 // indexClass: "@#record#memory"
 ```
@@ -187,16 +187,16 @@ await destroyEntity({ id: "123", model: "record" });
 
 ### Hierarchical Entities
 
-Use `calculateOu` to derive OU from parent:
+Use `calculateScope` to derive scope from parent:
 
 ```typescript
-import { calculateOu, putEntity, queryByOu } from "@jaypie/dynamodb";
+import { calculateScope, putEntity, queryByScope } from "@jaypie/dynamodb";
 
 // Parent reference
 const chat = { model: "chat", id: "abc-123" };
 
-// Calculate child OU
-const messageOu = calculateOu(chat); // "chat#abc-123"
+// Calculate child scope
+const messageScope = calculateScope(chat); // "chat#abc-123"
 
 // Create child entity
 const message = await putEntity({
@@ -204,39 +204,39 @@ const message = await putEntity({
     model: "message",
     id: crypto.randomUUID(),
     name: "First message",
-    ou: messageOu,
+    scope: messageScope,
     sequence: Date.now(),
     createdAt: now,
     updatedAt: now,
   },
 });
-// indexOu: "chat#abc-123#message"
+// indexScope: "chat#abc-123#message"
 
 // Query all messages in chat
-const { items } = await queryByOu({ model: "message", ou: messageOu });
+const { items } = await queryByScope({ model: "message", scope: messageScope });
 ```
 
 ## Query Functions
 
 All queries use object parameters and filter soft-deleted and archived records by default.
 
-### queryByOu - List by Parent
+### queryByScope - List by Parent
 
 List all entities of a model under a parent:
 
 ```typescript
-import { APEX, queryByOu } from "@jaypie/dynamodb";
+import { APEX, queryByScope } from "@jaypie/dynamodb";
 
 // Root-level records
-const { items, lastEvaluatedKey } = await queryByOu({
+const { items, lastEvaluatedKey } = await queryByScope({
   model: "record",
-  ou: APEX,
+  scope: APEX,
 });
 
 // Messages under a chat
-const { items: messages } = await queryByOu({
+const { items: messages } = await queryByScope({
   model: "message",
-  ou: "chat#abc-123",
+  scope: "chat#abc-123",
 });
 ```
 
@@ -250,7 +250,7 @@ import { APEX, queryByAlias } from "@jaypie/dynamodb";
 const record = await queryByAlias({
   alias: "2026-01-07",
   model: "record",
-  ou: APEX,
+  scope: APEX,
 });
 // Returns entity or null
 ```
@@ -263,14 +263,14 @@ import { APEX, queryByClass, queryByType } from "@jaypie/dynamodb";
 // All memory records
 const { items } = await queryByClass({
   model: "record",
-  ou: APEX,
+  scope: APEX,
   recordClass: "memory",
 });
 
 // All note-type records
 const { items: notes } = await queryByType({
   model: "record",
-  ou: APEX,
+  scope: APEX,
   type: "note",
 });
 ```
@@ -284,7 +284,7 @@ import { APEX, queryByXid } from "@jaypie/dynamodb";
 
 const record = await queryByXid({
   model: "record",
-  ou: APEX,
+  scope: APEX,
   xid: "ext-12345",
 });
 // Returns entity or null
@@ -295,9 +295,9 @@ const record = await queryByXid({
 ```typescript
 import type { BaseQueryOptions } from "@jaypie/dynamodb";
 
-const result = await queryByOu({
+const result = await queryByScope({
   model: "record",
-  ou: APEX,
+  scope: APEX,
   // BaseQueryOptions:
   limit: 25,                // Max items to return
   ascending: true,          // Oldest first (default: false = newest first)
@@ -310,15 +310,15 @@ const result = await queryByOu({
 ### Pagination
 
 ```typescript
-import { APEX, queryByOu } from "@jaypie/dynamodb";
+import { APEX, queryByScope } from "@jaypie/dynamodb";
 
 let startKey: Record<string, unknown> | undefined;
-const allItems: FabricEntity[] = [];
+const allItems: StorableEntity[] = [];
 
 do {
-  const { items, lastEvaluatedKey } = await queryByOu({
+  const { items, lastEvaluatedKey } = await queryByScope({
     model: "record",
-    ou: APEX,
+    scope: APEX,
     limit: 100,
     startKey,
   });
@@ -337,11 +337,11 @@ import { indexEntity } from "@jaypie/dynamodb";
 const indexed = indexEntity({
   model: "record",
   id: "123",
-  ou: "@",
+  scope: "@",
   alias: "my-alias",
   // ...
 });
-// indexOu: "@#record"
+// indexScope: "@#record"
 // indexAlias: "@#record#my-alias"
 ```
 
@@ -349,14 +349,14 @@ Use individual key builders for manual key construction:
 
 ```typescript
 import {
-  buildIndexOu,
+  buildIndexScope,
   buildIndexAlias,
   buildIndexClass,
   buildIndexType,
   buildIndexXid,
 } from "@jaypie/dynamodb";
 
-buildIndexOu("@", "record");                    // "@#record"
+buildIndexScope("@", "record");                 // "@#record"
 buildIndexAlias("@", "record", "my-alias");     // "@#record#my-alias"
 buildIndexClass("@", "record", "memory");       // "@#record#memory"
 buildIndexType("@", "record", "note");          // "@#record#note"
@@ -369,7 +369,7 @@ buildIndexXid("@", "record", "ext-123");        // "@#record#ext-123"
 import {
   APEX,           // "@" - Root-level marker
   SEPARATOR,      // "#" - Composite key separator
-  INDEX_OU,       // "indexOu"
+  INDEX_SCOPE,    // "indexScope"
   INDEX_ALIAS,    // "indexAlias"
   INDEX_CLASS,    // "indexClass"
   INDEX_TYPE,     // "indexType"
@@ -385,7 +385,7 @@ AttributeDefinitions:
     AttributeType: S
   - AttributeName: id
     AttributeType: S
-  - AttributeName: indexOu
+  - AttributeName: indexScope
     AttributeType: S
   - AttributeName: indexAlias
     AttributeType: S
@@ -405,9 +405,9 @@ KeySchema:
     KeyType: RANGE
 
 GlobalSecondaryIndexes:
-  - IndexName: indexOu
+  - IndexName: indexScope
     KeySchema:
-      - AttributeName: indexOu
+      - AttributeName: indexScope
         KeyType: HASH
       - AttributeName: sequence
         KeyType: RANGE
@@ -445,7 +445,7 @@ const created = await seedEntityIfNotExists({
   alias: "config-main",
   model: "config",
   name: "Main Configuration",
-  ou: APEX,
+  scope: APEX,
 });
 // Returns true if created, false if already exists
 ```
@@ -458,8 +458,8 @@ Seed multiple entities with idempotency:
 import { APEX, seedEntities } from "@jaypie/dynamodb";
 
 const result = await seedEntities([
-  { alias: "vocab-en", model: "vocabulary", name: "English", ou: APEX },
-  { alias: "vocab-es", model: "vocabulary", name: "Spanish", ou: APEX },
+  { alias: "vocab-en", model: "vocabulary", name: "English", scope: APEX },
+  { alias: "vocab-es", model: "vocabulary", name: "Spanish", scope: APEX },
 ]);
 // result.created: aliases of created entities
 // result.skipped: aliases of entities that already existed
@@ -476,13 +476,13 @@ Auto-generates `id` (UUID), `createdAt`, `updatedAt`, and `sequence` if missing.
 
 ### exportEntities
 
-Export entities by model and organizational unit:
+Export entities by model and scope:
 
 ```typescript
 import { APEX, exportEntities } from "@jaypie/dynamodb";
 
 const { entities, count } = await exportEntities("vocabulary", APEX);
-// entities: FabricEntity[] sorted by sequence ascending
+// entities: StorableEntity[] sorted by sequence ascending
 // count: number of entities
 
 // With limit
@@ -517,7 +517,7 @@ interface SeedOptions {
   dryRun?: boolean;    // Preview without writing (default: false)
 }
 
-interface ExportResult<T extends FabricEntity = FabricEntity> {
+interface ExportResult<T extends StorableEntity = StorableEntity> {
   entities: T[];       // Exported entities
   count: number;       // Number of entities
 }
@@ -546,11 +546,11 @@ import {
   exportEntities,
   getEntity,
   putEntity,
-  queryByOu,
+  queryByScope,
   seedEntities,
 } from "@jaypie/testkit/mock";
 
-queryByOu.mockResolvedValue({
+queryByScope.mockResolvedValue({
   items: [{ id: "123", name: "Test" }],
   lastEvaluatedKey: undefined,
 });
@@ -644,12 +644,12 @@ await deleteEntity({ id: "123", model: "record" });
 await archiveEntity({ id: "123", model: "record" });
 
 // Queries exclude both by default
-const { items } = await queryByOu({ model: "record", ou: APEX });
+const { items } = await queryByScope({ model: "record", scope: APEX });
 
 // Include if needed
-const { items: all } = await queryByOu({
+const { items: all } = await queryByScope({
   model: "record",
-  ou: APEX,
+  scope: APEX,
   includeDeleted: true,
   includeArchived: true,
 });
@@ -704,7 +704,7 @@ const { tools } = registerDynamoDbTools({ server });
 #### Query Operations
 | Tool | Description |
 |------|-------------|
-| `dynamodb_query_ou` | Query by organizational unit |
+| `dynamodb_query_scope` | Query by scope |
 | `dynamodb_query_alias` | Query by human-friendly alias |
 | `dynamodb_query_class` | Query by category classification |
 | `dynamodb_query_type` | Query by type classification |
@@ -753,15 +753,15 @@ Generate docker-compose and create table:
   "id": "abc-123",
   "model": "record",
   "name": "My Record",
-  "ou": "@",
+  "scope": "@",
   "alias": "my-record",
   "class": "memory"
 }
 
-// dynamodb_query_ou
+// dynamodb_query_scope
 {
   "model": "record",
-  "ou": "@",
+  "scope": "@",
   "limit": 10
 }
 

package/prompts/Jaypie_Express_Package.md

@@ -407,50 +407,6 @@ expressHandler automatically sets these headers:
 
 When Datadog environment variables are configured, expressHandler automatically submits metrics for each request including status code and path.
 
-## Server Creation
-
-Use `createServer` to quickly set up an Express server with standard Jaypie middleware.
-
-### Basic Server Usage
-
-```typescript
-import express from "express";
-import { createServer, expressHandler } from "jaypie";
-
-const app = express();
-
-app.get("/", expressHandler(async (req, res) => {
-  return { message: "Hello World" };
-}));
-
-const { server, port } = await createServer(app);
-console.log(`Server running on port ${port}`);
-```
-
-### Server Options
-
-```typescript
-import { createServer } from "jaypie";
-import type { CreateServerOptions } from "jaypie";
-
-const options: CreateServerOptions = {
-  port: 3000,              // Port to listen on (default: PORT env var or 8080)
-  cors: { origin: "*" },   // CORS config (false to disable)
-  jsonLimit: "10mb",       // JSON body parser limit (default: "1mb")
-  middleware: [myMiddleware], // Additional middleware to apply
-};
-
-const { server, port } = await createServer(app, options);
-```
-
-### Server Result
-
-```typescript
-import type { ServerResult } from "jaypie";
-
-// { server: Server, port: number }
-```
-
 ## Streaming Responses
 
 Use `expressStreamHandler` for Server-Sent Events (SSE) streaming responses. Ideal for real-time updates, LLM streaming, and long-running operations.
@@ -542,6 +498,107 @@ import type {
 } from "jaypie";
 ```
 
+## Lambda Handlers
+
+Create Lambda handlers from Express apps using `createLambdaHandler` and `createLambdaStreamHandler`. These functions wrap Express applications to run directly on AWS Lambda Function URLs without requiring a separate Lambda adapter library.
+
+### Buffered Handler
+
+Use `createLambdaHandler` for standard Lambda responses where the entire response is buffered before sending.
+
+```typescript
+import express from "express";
+import { createLambdaHandler, expressHandler } from "jaypie";
+
+const app = express();
+
+app.get("/", expressHandler(async (req, res) => {
+  return { message: "Hello from Lambda!" };
+}));
+
+// Export for Lambda Function URL
+export const handler = createLambdaHandler(app);
+```
+
+### Streaming Handler
+
+Use `createLambdaStreamHandler` for Lambda response streaming, ideal for Server-Sent Events (SSE) and real-time updates.
+
+```typescript
+import express from "express";
+import { createLambdaStreamHandler, expressStreamHandler } from "jaypie";
+
+const app = express();
+
+app.get("/stream", expressStreamHandler(async (req, res) => {
+  res.write("event: message\ndata: {\"text\": \"Hello\"}\n\n");
+  res.write("event: message\ndata: {\"text\": \"World\"}\n\n");
+}));
+
+// Export for Lambda Function URL with streaming
+export const handler = createLambdaStreamHandler(app);
+```
+
+### Combined Usage
+
+A typical Lambda Express application with both buffered and streaming endpoints:
+
+```typescript
+import express from "express";
+import {
+  createLambdaHandler,
+  createLambdaStreamHandler,
+  expressHandler,
+  expressStreamHandler,
+  cors,
+} from "jaypie";
+
+const app = express();
+app.use(express.json());
+app.use(cors());
+
+// Standard buffered route
+app.get("/api/data", expressHandler(async (req, res) => {
+  return { data: "buffered response" };
+}));
+
+// SSE streaming route
+app.get("/api/stream", expressStreamHandler(async (req, res) => {
+  for (let i = 0; i < 5; i++) {
+    res.write(`event: update\ndata: {"count": ${i}}\n\n`);
+  }
+}));
+
+// Choose handler based on your needs
+// For buffered: export const handler = createLambdaHandler(app);
+// For streaming: export const handler = createLambdaStreamHandler(app);
+export const handler = createLambdaHandler(app);
+```
+
+### Lambda Context Access
+
+Both handlers expose Lambda context on the request object:
+
+```typescript
+app.get("/", expressHandler(async (req, res) => {
+  // Access Lambda context directly on request
+  const awsRequestId = (req as any)._lambdaContext?.awsRequestId;
+  return { requestId: awsRequestId };
+}));
+```
+
+### TypeScript Types
+
+```typescript
+import type {
+  LambdaHandler,
+  LambdaStreamHandler,
+  LambdaContext,
+  FunctionUrlEvent,
+  LambdaResponse,
+} from "jaypie";
+```
+
 ## Invoke UUID Detection
 
 Use `getCurrentInvokeUuid` to get the current request ID. Automatically detects the environment (Lambda, Lambda Web Adapter, or local development).