@jaypie/mcp 0.2.7 → 0.2.9

package/dist/index.js

@@ -885,7 +885,7 @@ function listLlmProviders() {
     };
 }
 
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.7#8fb79282"
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.9#f022ac30"
     ;
 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.7",
+  "version": "0.2.9",
   "description": "Jaypie MCP",
   "repository": {
     "type": "git",

package/prompts/Jaypie_CDK_Constructs_and_Patterns.md

@@ -102,54 +102,52 @@ Preconfigured with API-optimized timeouts and role tags.
 
 ### Streaming Lambda Functions
 
-Enable Lambda Response Streaming via Function URLs for real-time SSE responses:
+Use `JaypieStreamingLambda` for Express apps with AWS Lambda Web Adapter and streaming support:
 
 ```typescript
-import { FunctionUrlAuthType, InvokeMode } from "aws-cdk-lib/aws-lambda";
-
-const streamingLambda = new JaypieLambda(this, "StreamingFunction", {
-  code: "dist",
-  handler: "stream.handler",
-  timeout: Duration.minutes(5), // Longer timeout for streaming
+import { JaypieStreamingLambda, JaypieDistribution } from "@jaypie/constructs";
+
+// Create streaming Lambda with Web Adapter
+const streamingLambda = new JaypieStreamingLambda(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)
 });
 
-// Add Function URL with streaming enabled
-const functionUrl = streamingLambda.addFunctionUrl({
-  authType: FunctionUrlAuthType.NONE,     // Public access
-  // authType: FunctionUrlAuthType.AWS_IAM, // IAM authentication
-  invokeMode: InvokeMode.RESPONSE_STREAM, // Enable streaming
-});
-
-// Output the URL
-new cdk.CfnOutput(this, "StreamingUrl", {
-  value: functionUrl.url,
+// CloudFront auto-detects invokeMode from JaypieStreamingLambda
+new JaypieDistribution(this, "Distribution", {
+  handler: streamingLambda,
+  host: "api.example.com",
+  zone: "example.com",
 });
 ```
 
 Features:
-- `RESPONSE_STREAM` invoke mode enables real-time streaming
-- Works with `lambdaStreamHandler` from `@jaypie/lambda`
-- Use `FunctionUrlAuthType.AWS_IAM` for authenticated endpoints
-- Combine with API Gateway for custom domains via `JaypieApiGateway`
+- 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 Express-based streaming with custom domains:
+For direct Function URL access (bypass CloudFront):
 ```typescript
-// Express app with streaming routes
-const expressLambda = new JaypieExpressLambda(this, "ExpressStream", {
+import { FunctionUrlAuthType, InvokeMode } from "aws-cdk-lib/aws-lambda";
+
+const streamingLambda = new JaypieLambda(this, "StreamingFunction", {
   code: "dist",
-  handler: "app.handler",
+  handler: "stream.handler",
   timeout: Duration.minutes(5),
 });
 
-// API Gateway handles the domain routing
-new JaypieApiGateway(this, "Api", {
-  handler: expressLambda,
-  host: "api.example.com",
-  zone: "example.com",
+const functionUrl = streamingLambda.addFunctionUrl({
+  authType: FunctionUrlAuthType.NONE,
+  invokeMode: InvokeMode.RESPONSE_STREAM,
 });
+
+new cdk.CfnOutput(this, "StreamingUrl", { value: functionUrl.url });
 ```
 
-Note: API Gateway has a 29-second timeout limit. For longer streaming operations, use Function URLs directly.
+Note: API Gateway has a 29-second timeout limit. For longer streaming operations, use Function URLs or CloudFront with Lambda Function URLs.
 
 ### Stack Types
 

package/prompts/Jaypie_DynamoDB_Package.md

@@ -430,6 +430,99 @@ try {
 }
 ```
 
+## Seed and Export Utilities
+
+Idempotent seeding and data export for migrations and bootstrapping.
+
+### seedEntityIfNotExists
+
+Seed a single entity if it doesn't already exist (checked by alias):
+
+```typescript
+import { APEX, seedEntityIfNotExists } from "@jaypie/dynamodb";
+
+const created = await seedEntityIfNotExists({
+  alias: "config-main",
+  model: "config",
+  name: "Main Configuration",
+  ou: APEX,
+});
+// Returns true if created, false if already exists
+```
+
+### seedEntities
+
+Seed multiple entities with idempotency:
+
+```typescript
+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 },
+]);
+// result.created: aliases of created entities
+// result.skipped: aliases of entities that already existed
+// result.errors: { alias, error } for failed operations
+
+// Dry run (preview without writing)
+const preview = await seedEntities(entities, { dryRun: true });
+
+// Replace existing entities
+await seedEntities(entities, { replace: true });
+```
+
+Auto-generates `id` (UUID), `createdAt`, `updatedAt`, and `sequence` if missing.
+
+### exportEntities
+
+Export entities by model and organizational unit:
+
+```typescript
+import { APEX, exportEntities } from "@jaypie/dynamodb";
+
+const { entities, count } = await exportEntities("vocabulary", APEX);
+// entities: FabricEntity[] sorted by sequence ascending
+// count: number of entities
+
+// With limit
+const { entities: limited } = await exportEntities("vocabulary", APEX, 100);
+```
+
+### exportEntitiesToJson
+
+Export as JSON string:
+
+```typescript
+import { APEX, exportEntitiesToJson } from "@jaypie/dynamodb";
+
+const json = await exportEntitiesToJson("vocabulary", APEX);
+// Pretty printed by default
+
+const compact = await exportEntitiesToJson("vocabulary", APEX, false);
+// Compact JSON
+```
+
+### SeedResult Interface
+
+```typescript
+interface SeedResult {
+  created: string[];   // Aliases of created entities
+  skipped: string[];   // Aliases of skipped entities (already exist)
+  errors: Array<{ alias: string; error: string }>;
+}
+
+interface SeedOptions {
+  replace?: boolean;   // Overwrite existing (default: false)
+  dryRun?: boolean;    // Preview without writing (default: false)
+}
+
+interface ExportResult<T extends FabricEntity = FabricEntity> {
+  entities: T[];       // Exported entities
+  count: number;       // Number of entities
+}
+```
+
 ## Testing
 
 Mock implementations in `@jaypie/testkit`:
@@ -445,9 +538,17 @@ vi.mock("@jaypie/dynamodb", async () => {
 // Key builders and indexEntity work correctly (delegate to real implementations)
 // Query functions return empty results by default
 // Entity operations return sensible defaults
+// Seed functions return { created: [], skipped: [], errors: [] } by default
+// Export functions return { entities: [], count: 0 } by default
 
 // Customize mock behavior:
-import { queryByOu, getEntity, putEntity } from "@jaypie/testkit/mock";
+import {
+  exportEntities,
+  getEntity,
+  putEntity,
+  queryByOu,
+  seedEntities,
+} from "@jaypie/testkit/mock";
 
 queryByOu.mockResolvedValue({
   items: [{ id: "123", name: "Test" }],
@@ -455,6 +556,17 @@ queryByOu.mockResolvedValue({
 });
 
 getEntity.mockResolvedValue({ id: "123", model: "record", name: "Test" });
+
+seedEntities.mockResolvedValue({
+  created: ["entity-1", "entity-2"],
+  skipped: [],
+  errors: [],
+});
+
+exportEntities.mockResolvedValue({
+  entities: [{ id: "123", model: "record" }],
+  count: 1,
+});
 ```
 
 ## Best Practices

package/prompts/Jaypie_Express_Package.md

@@ -407,6 +407,50 @@ 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.
@@ -497,3 +541,33 @@ import type {
   JaypieStreamHandlerValidate,
 } from "jaypie";
 ```
+
+## Invoke UUID Detection
+
+Use `getCurrentInvokeUuid` to get the current request ID. Automatically detects the environment (Lambda, Lambda Web Adapter, or local development).
+
+### Basic Usage
+
+```typescript
+import { getCurrentInvokeUuid } from "jaypie";
+
+const handler = expressHandler(async (req, res) => {
+  const invokeUuid = getCurrentInvokeUuid(req);
+  // Returns AWS request ID in Lambda, or generates a local UUID
+  return { requestId: invokeUuid };
+});
+```
+
+### Environment Detection
+
+The function adapts to different runtime environments:
+
+1. **Lambda (native)**: Uses `awsRequestId` from Lambda context
+2. **Lambda Web Adapter**: Extracts from `x-amzn-request-id` header or `_X_AMZN_TRACE_ID` env var
+3. **Local development**: Generates a UUID for consistent tracing
+
+### Lambda Web Adapter Headers
+
+When running Express behind AWS Lambda Web Adapter, the function extracts the request ID from:
+- `x-amzn-request-id` header (set by Lambda Web Adapter)
+- `_X_AMZN_TRACE_ID` environment variable (X-Ray trace ID, set by Lambda runtime)

package/prompts/Jaypie_Vocabulary_Package.md

@@ -162,6 +162,7 @@ Context callbacks connect to adapter registration:
 | `String` | `"string"`, `""` | String coercion |
 | `Number` | `"number"` | Number coercion |
 | `Boolean` | `"boolean"` | Boolean coercion |
+| `Date` | `DateType` | Date coercion (ISO strings, timestamps) |
 | `Array` | `"array"`, `[]` | Array coercion |
 | `Object` | `"object"`, `{}` | Object coercion |
 | `[String]` | `[""]` | Typed array of strings |
@@ -171,6 +172,7 @@ Context callbacks connect to adapter registration:
 | `/regex/` | - | String with regex validation |
 | `["a", "b"]` | - | Validated string (must match) |
 | `[1, 2, 3]` | - | Validated number (must match) |
+| `StatusType` | - | Validated status ("pending", "processing", etc.) |
 
 ### Coercion Examples
 
@@ -201,6 +203,14 @@ coerce([1, 2], [String]);    // → ["1", "2"]
 coerce({ value: "42" }, Number);  // → 42
 coerce(["true"], Boolean);        // → true
 coerce('{"value": 5}', Number);   // → 5
+
+// Date coercion
+import { coerceToDate, coerceFromDate } from "@jaypie/vocabulary";
+
+coerceToDate("2026-01-15T10:30:00Z");  // → Date object
+coerceToDate(1736942400000);            // → Date from timestamp
+coerceFromDate(new Date(), String);     // → ISO string
+coerceFromDate(new Date(), Number);     // → Unix timestamp (ms)
 ```
 
 ### RegExp Type Shorthand
@@ -236,6 +246,30 @@ input: {
 }
 ```
 
+### StatusType
+
+A predefined validated string type for common status values:
+
+```typescript
+import { StatusType, isStatus, STATUS_VALUES } from "@jaypie/vocabulary";
+
+// StatusType is: ["canceled", "complete", "error", "pending", "processing", "queued", "sending"]
+
+const handler = serviceHandler({
+  input: {
+    status: { type: StatusType, default: "pending" },
+  },
+  service: ({ status }) => status,
+});
+
+await handler({ status: "processing" });  // ✓
+await handler({ status: "invalid" });     // ✗ BadRequestError
+
+// Type guard
+isStatus("pending");   // → true
+isStatus("unknown");   // → false
+```
+
 ## Entity Types
 
 The vocabulary provides standard entity types for consistent data modeling:
@@ -302,6 +336,40 @@ progress?:
     nextPercentageCheckpoint?: Number
 ```
 
+### BaseEntity Utilities
+
+Field constants and utility functions for working with entities:
+
+```typescript
+import {
+  // Field name constants
+  BASE_ENTITY_FIELDS,           // All field names as constants
+  BASE_ENTITY_REQUIRED_FIELDS,  // ["createdAt", "id", "model", "updatedAt"]
+  BASE_ENTITY_AUTO_FIELDS,      // ["createdAt", "history", "id", "updatedAt"]
+  BASE_ENTITY_TIMESTAMP_FIELDS, // ["archivedAt", "createdAt", "deletedAt", "updatedAt"]
+
+  // Type guards
+  isBaseEntity,        // Check if value is a complete BaseEntity
+  hasBaseEntityShape,  // Check if value has minimum shape (id + model)
+
+  // Field helpers
+  isAutoField,         // Check if field is auto-generated
+  isTimestampField,    // Check if field is a timestamp
+
+  // Utilities
+  createBaseEntityInput,  // Create minimal input with required model
+  pickBaseEntityFields,   // Extract only BaseEntity fields from object
+} from "@jaypie/vocabulary";
+
+// Example: Check if a field should be auto-generated
+isAutoField("id");        // → true
+isAutoField("name");      // → false
+
+// Example: Extract BaseEntity fields from mixed object
+const mixed = { id: "123", model: "record", customField: "value" };
+pickBaseEntityFields(mixed);  // → { id: "123", model: "record" }
+```
+
 ## TypeScript Types
 
 ```typescript
@@ -315,20 +383,22 @@ import type {
   Job,
   MessageEntity,
   Progress,
+  Status,
 
   // Message types
   Message,
   MessageLevel,
 
   // Coercion types
+  ArrayElementType,
   CoercionType,
-  ScalarType,
   CompositeType,
+  DateCoercionType,
+  RegExpType,
+  ScalarType,
   TypedArrayType,
-  ValidatedStringType,
   ValidatedNumberType,
-  RegExpType,
-  ArrayElementType,
+  ValidatedStringType,
 
   // Service handler types
   InputFieldDefinition,
@@ -358,6 +428,20 @@ interface Message {
 ### Main Export (`@jaypie/vocabulary`)
 
 ```typescript
+// BaseEntity utilities
+export {
+  BASE_ENTITY_AUTO_FIELDS,
+  BASE_ENTITY_FIELDS,
+  BASE_ENTITY_REQUIRED_FIELDS,
+  BASE_ENTITY_TIMESTAMP_FIELDS,
+  createBaseEntityInput,
+  hasBaseEntityShape,
+  isAutoField,
+  isBaseEntity,
+  isTimestampField,
+  pickBaseEntityFields,
+} from "./base-entity.js";
+
 // Coercion functions
 export {
   coerce,
@@ -370,17 +454,28 @@ export {
   coerceToString,
 } from "./coerce.js";
 
+// Date coercion
+export {
+  coerceFromDate,
+  coerceToDate,
+  DateType,
+  isDateType,
+  isValidDate,
+} from "./coerce-date.js";
+
+// Status type
+export { isStatus, STATUS_VALUES, StatusType } from "./status.js";
+
 // Service Handler
 export { serviceHandler } from "./serviceHandler.js";
 
-// Adapter namespaces
-export * as commander from "./commander/index.js";
-export * as lambda from "./lambda/index.js";
+// LLM adapter (re-exported, no optional deps)
 export * as llm from "./llm/index.js";
-export * as mcp from "./mcp/index.js";
 
-// Types (including Message vocabulary and ServiceContext)
-export type { Message, MessageLevel, ServiceContext } from "./types.js";
+// Note: Other adapters have optional dependencies and must be imported directly:
+//   import { registerServiceCommand } from "@jaypie/vocabulary/commander";
+//   import { lambdaServiceHandler } from "@jaypie/vocabulary/lambda";
+//   import { registerMcpTool } from "@jaypie/vocabulary/mcp";
 
 // Version
 export const VOCABULARY_VERSION: string;