@jaypie/mcp 0.2.6 → 0.2.7

package/dist/index.js

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

package/prompts/Jaypie_CDK_Constructs_and_Patterns.md

@@ -153,12 +153,44 @@ Note: API Gateway has a 29-second timeout limit. For longer streaming operations
 
 ### Stack Types
 
-Use specialized stacks for different purposes:
+Always extend Jaypie stack classes instead of raw CDK classes:
+
+| Use | Instead of |
+|-----|------------|
+| `JaypieAppStack` | `cdk.Stack` |
+| `JaypieInfrastructureStack` | `cdk.Stack` |
+
+Jaypie stacks automatically configure:
+- `env` with `CDK_DEFAULT_ACCOUNT` and `CDK_DEFAULT_REGION` (required for context providers)
+- Standard tagging
+- Removal policies based on environment
+
 ```typescript
 new JaypieAppStack(scope, "AppStack");  // Application resources
 new JaypieInfrastructureStack(scope, "InfraStack");  // Infrastructure resources
 ```
 
+#### Error: Using cdk.Stack with Context Providers
+
+Using `cdk.Stack` directly with constructs that need context providers causes:
+
+```
+ValidationError: Cannot retrieve value from context provider hosted-zone since
+account/region are not specified at the stack level.
+```
+
+**Solution:** Change the base class:
+
+```typescript
+// Wrong
+import * as cdk from "aws-cdk-lib";
+export class AppStack extends cdk.Stack { ... }
+
+// Correct
+import { JaypieAppStack } from "@jaypie/constructs";
+export class AppStack extends JaypieAppStack { ... }
+```
+
 ### Secrets Management
 
 Use `JaypieEnvSecret` for cross-stack secret sharing:
@@ -314,7 +346,7 @@ const table = new JaypieDynamoDb(this, "MyTable", {
 // Connect table to Lambda
 new JaypieLambda(this, "Worker", {
   code: "dist",
-  tables: [table], // Grants read/write, sets CDK_ENV_DYNAMO_TABLE
+  tables: [table], // Grants read/write, sets DYNAMODB_TABLE_NAME
 });
 ```
 

package/prompts/Jaypie_CICD_with_GitHub_Actions.md

@@ -190,6 +190,25 @@ Pass secrets only to steps that need them:
 
 Never expose secrets in logs or workflow outputs.
 
+## CDK Stack Names
+
+The `stack-name` parameter in deploy workflows must match the stack ID defined in `packages/cdk/bin/cdk.ts`:
+
+```typescript
+// bin/cdk.ts
+new AppStack(app, "AppStack");  // "AppStack" is the stack ID
+```
+
+```yaml
+# deploy-*.yml
+- name: Deploy CDK Stack
+  uses: ./.github/actions/cdk-deploy
+  with:
+    stack-name: AppStack  # Must match the stack ID above
+```
+
+If you rename the stack ID (e.g., to "MyProjectAppStack" for clarity in AWS), update all deploy workflows to match. Mismatched names cause "No stacks match the name(s)" errors.
+
 ## Integrations
 
 ### AWS

package/prompts/Jaypie_Fabricator.md

@@ -359,3 +359,259 @@ class TenantFabricator {
 4. **Seed Flexibility**: Accepts strings, numbers, or UUIDs as seeds
 5. **Hierarchical Generation**: Nested fabricators enable deterministic tree structures for complex data models
 6. **Identity & Naming**: Every fabricator has a unique ID and name for tracking and debugging
+
+## EventFabricator: Temporal Event Generation
+
+### Overview
+
+`EventFabricator` is an abstract base class for generating temporally-distributed events across a year. It builds on `Fabricator` to add:
+- Annual event counts with configurable distribution
+- Temporal templates for hour, day, week, month, and date weighting
+- Timezone-aware hour shifting
+- Derived event system for cascading events
+
+### Basic Usage
+
+```typescript
+import {
+  EventFabricator,
+  HOURS_BUSINESS,
+  DAYS_WEEKDAYS_ONLY,
+  type CreateEventParams,
+} from "@jaypie/fabricator";
+
+interface SimpleEvent {
+  id: string;
+  timestamp: Date;
+}
+
+class SimpleEventFabricator extends EventFabricator<SimpleEvent> {
+  protected createEvent({ seed, timestamp }: CreateEventParams): SimpleEvent {
+    return { id: seed, timestamp };
+  }
+}
+
+const fab = new SimpleEventFabricator({
+  seed: "my-events",
+  annualCount: 1000,
+  template: [HOURS_BUSINESS, DAYS_WEEKDAYS_ONLY],
+});
+
+const events = fab.events({ year: 2025 });
+// Returns 1000 events during business hours on weekdays
+```
+
+### Temporal Templates
+
+Templates control event distribution. They can be combined:
+
+**Hour Templates:**
+- `HOURS_BUSINESS` - 8am-5pm
+- `HOURS_RETAIL` - 10am-8pm
+- `HOURS_EVENING` - 6pm-10pm
+- `HOURS_24_7` - All hours equal
+
+**Day Templates:**
+- `DAYS_WEEKDAYS_ONLY` - Mon-Fri only
+- `DAYS_NO_SUNDAY` - All but Sunday
+- `DAYS_NO_MONDAY` - All but Monday
+
+**Curve Templates (gradual peaks):**
+- `CURVE_EVENING_PEAK` - Peaks at 7pm
+- `CURVE_ECOMMERCE` - Peaks at 8pm
+- `CURVE_MIDDAY_PEAK` - Peaks at 11am
+
+**Spike Templates (sharp peaks):**
+- `SPIKE_MORNING` - 7-8am peak
+- `SPIKE_LUNCH` - 12-1pm peak
+- `SPIKE_EVENING` - 6-7pm peak
+
+**Boost/Lull Templates (multipliers):**
+- `BOOST_SUMMER`, `LULL_SUMMER`
+- `BOOST_WINTER`, `LULL_WINTER`
+- `BOOST_WEEKENDS`, `LULL_WEEKENDS`
+- `BOOST_HOLIDAY_SEASON` - Nov-Dec 1.5x
+
+```typescript
+const fab = new MyFabricator({
+  template: [
+    HOURS_BUSINESS,
+    DAYS_WEEKDAYS_ONLY,
+    BOOST_HOLIDAY_SEASON,
+    CURVE_MIDDAY_PEAK,
+  ],
+});
+```
+
+## Derived Events: Cascading Event Generation
+
+### Overview
+
+The derived event system allows events to spawn follow-up events based on probabilistic rules. This is ideal for modeling:
+- Financial transactions with voids, refunds, chargebacks
+- Subscription renewals with payment retries
+- Any event chains with cause-and-effect relationships
+
+### Configuration
+
+```typescript
+import {
+  EventFabricator,
+  CHANCE,
+  type DerivedConfig,
+  type TimestampedEvent,
+} from "@jaypie/fabricator";
+
+interface Transaction extends TimestampedEvent {
+  id: string;
+  amount: number;
+  type: "purchase" | "void" | "refund" | "chargeback";
+  parentId?: string;
+  timestamp: Date;
+}
+
+const derivedConfig: DerivedConfig<Transaction> = {
+  rules: [
+    {
+      name: "void",
+      probability: CHANCE.RARE,  // 2.1%
+      condition: (parent) => parent.type === "purchase",
+      timing: { mode: "same-day" },
+      createDerived: ({ parent, seed, timestamp }) => ({
+        id: seed,
+        type: "void",
+        amount: -parent.amount,
+        timestamp,
+        parentId: parent.id,
+      }),
+    },
+    {
+      name: "refund",
+      probability: 0.10,  // 10%
+      timing: {
+        mode: "range",
+        delayMin: 1,
+        delayMax: 14,
+        unit: "days",
+      },
+      createDerived: ({ parent, seed, timestamp }) => ({
+        id: seed,
+        type: "refund",
+        amount: -parent.amount,
+        timestamp,
+        parentId: parent.id,
+      }),
+    },
+  ],
+  boundaryBehavior: "include",  // include | exclude | clamp
+  maxDepth: 4,  // Prevent infinite chains
+};
+```
+
+### Timing Modes
+
+```typescript
+interface DerivedTiming {
+  mode: "same-day" | "fixed" | "range" | "recurring";
+  delayMin?: number;
+  delayMax?: number;
+  unit?: "days" | "weeks" | "months" | "hours" | "minutes" | "seconds";
+  interval?: number;          // For recurring
+  maxRecurrences?: number;    // For recurring
+  until?: Date | "end-of-year";
+}
+```
+
+**Examples:**
+- Same day: `{ mode: "same-day" }`
+- Fixed delay: `{ mode: "fixed", delayMin: 7, unit: "days" }`
+- Range: `{ mode: "range", delayMin: 1, delayMax: 14, unit: "days" }`
+- Monthly recurring: `{ mode: "recurring", interval: 1, unit: "months", until: "end-of-year" }`
+
+### Nested Derived Events (Chains)
+
+Derived events can spawn their own derived events:
+
+```typescript
+{
+  name: "chargeback",
+  probability: CHANCE.RARE,
+  timing: { mode: "range", delayMin: 30, delayMax: 90, unit: "days" },
+  createDerived: ({ parent, seed, timestamp }) => ({
+    id: seed,
+    type: "chargeback",
+    amount: -parent.amount,
+    timestamp,
+    parentId: parent.id,
+  }),
+  derived: [  // Nested rules for chargebacks
+    {
+      name: "representment",
+      probability: 0.70,  // 70% of chargebacks
+      timing: { mode: "range", delayMin: 7, delayMax: 21, unit: "days" },
+      createDerived: ({ parent, seed, timestamp }) => ({
+        id: seed,
+        type: "representment",
+        amount: Math.abs(parent.amount),  // Re-charge
+        timestamp,
+        parentId: parent.id,
+      }),
+    },
+  ],
+}
+```
+
+### Using with EventFabricator
+
+```typescript
+class TransactionFabricator extends EventFabricator<Transaction> {
+  constructor(options = {}) {
+    super({
+      ...options,
+      derived: derivedConfig,
+      template: [HOURS_BUSINESS, DAYS_WEEKDAYS_ONLY],
+    });
+  }
+
+  protected createEvent({ seed, timestamp }: CreateEventParams): Transaction {
+    const fab = new Fabricator({ seed });
+    return {
+      id: seed,
+      type: "purchase",
+      amount: fab.random({ min: 10, max: 500, currency: true }),
+      timestamp,
+    };
+  }
+}
+
+const fab = new TransactionFabricator({
+  seed: "my-business",
+  annualCount: 1000,
+});
+
+// Get all events including derived events
+const events = fab.events({ year: 2025 });
+
+// Get events with metadata (parent refs, depth, rule names)
+const eventsWithMeta = fab.eventsWithMeta({ year: 2025 });
+```
+
+### Event Metadata
+
+`eventsWithMeta()` returns events with relationship data:
+
+```typescript
+interface EventWithDerivedMeta<T> {
+  event: T;
+  depth: number;        // 0 = primary, 1 = first derived, etc.
+  parentSeed?: string;  // Seed of parent event
+  ruleName?: string;    // Rule that created this derived event
+}
+```
+
+### Key Properties
+
+1. **Deterministic**: Same seed produces same derived event cascade
+2. **Chronological**: All events (primary + derived) sorted by timestamp
+3. **Depth-Limited**: `maxDepth` prevents infinite chains
+4. **Boundary Control**: Events outside target year can be included, excluded, or clamped

package/prompts/Jaypie_Init_CICD_with_GitHub_Actions.md

@@ -1115,6 +1115,22 @@ The environment must be created in GitHub repository settings before the workflo
 - Verify the AWS role has permissions to access any Secrets Manager secrets
 - Review CloudFormation events in the AWS Console for specific errors
 
+### Error: "Cannot retrieve value from context provider hosted-zone"
+
+Stacks using context providers must extend `JaypieAppStack`, not `cdk.Stack`:
+
+```typescript
+// Wrong
+import * as cdk from "aws-cdk-lib";
+export class AppStack extends cdk.Stack { ... }
+
+// Correct
+import { JaypieAppStack } from "@jaypie/constructs";
+export class AppStack extends JaypieAppStack { ... }
+```
+
+`JaypieAppStack` automatically sets `env` with `CDK_DEFAULT_ACCOUNT` and `CDK_DEFAULT_REGION`.
+
 ### Variables Not Being Applied
 
 - Composite actions cannot access `vars.*` directly

package/prompts/Templates_CDK_Subpackage.md

@@ -22,6 +22,8 @@ new InfrastructureStack(app, "InfrastructureStack");
 new AppStack(app, "AppStack");
 ```
 
+> **Important:** The second argument to `new AppStack(app, "AppStack")` is the stack ID used by CloudFormation. This must exactly match the `stack-name` parameter in your GitHub Actions deploy workflows. If you customize this value (e.g., `"MyProjectAppStack"`), update `.github/workflows/deploy-*.yml` accordingly.
+
 ## lib/cdk-app.ts
 
 ```typescript