@auto-engineer/narrative 1.3.2 → 1.3.4

package/package.json

@@ -23,9 +23,9 @@
     "typescript": "^5.9.2",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3",
-    "@auto-engineer/message-bus": "1.3.2",
-    "@auto-engineer/id": "1.3.2",
-    "@auto-engineer/file-store": "1.3.2"
+    "@auto-engineer/id": "1.3.4",
+    "@auto-engineer/file-store": "1.3.4",
+    "@auto-engineer/message-bus": "1.3.4"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -35,7 +35,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.2",
+  "version": "1.3.4",
   "scripts": {
     "build": "tsx scripts/build.ts",
     "test": "vitest run --reporter=dot",

package/src/model-to-narrative.specs.ts

@@ -3148,5 +3148,296 @@ narrative('All Projection Types', 'ALL-PROJ', () => {
       const code = getCode(await modelToNarrative(modelWithSourceInstructions));
       expect(code).toContain(".additionalInstructions('Filter by active orders only')");
     });
+
+    it('should generate 3 narrative files for gym membership model', async () => {
+      const gymModel: Model = {
+        variant: 'specs',
+        narratives: [
+          {
+            id: 'mrwDfHhDi',
+            name: 'Gym Membership Registration',
+            slices: [
+              {
+                type: 'command',
+                name: 'Register New Member',
+                id: 'YcOe0aHz3',
+                client: { specs: [] },
+                server: {
+                  description: '',
+                  specs: [
+                    {
+                      type: 'gherkin',
+                      feature: '',
+                      rules: [
+                        {
+                          id: 'ODJGjsU2m',
+                          name: 'Member account creation process',
+                          examples: [
+                            {
+                              id: 'Jdrjvn3HV',
+                              name: 'Create member account',
+                              steps: [
+                                {
+                                  id: 'D1v4V3TEF',
+                                  keyword: 'When',
+                                  text: 'SubmitMembershipRegistration',
+                                  docString: { name: 'John Doe', email: 'john@example.com', phone: '123-456-7890' },
+                                },
+                                {
+                                  id: 'IeXOn8W9v',
+                                  keyword: 'Then',
+                                  text: 'MemberAccountCreated',
+                                  docString: {
+                                    memberId: 'mem_123',
+                                    name: 'John Doe',
+                                    email: 'john@example.com',
+                                    phone: '123-456-7890',
+                                  },
+                                },
+                              ],
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                  data: {
+                    items: [
+                      {
+                        target: { type: 'Event', name: 'MemberAccountCreated' },
+                        destination: { type: 'stream', pattern: 'members' },
+                      },
+                    ],
+                  },
+                },
+              },
+            ],
+            sourceFile: '/narratives/gym.narrative.ts',
+          },
+          {
+            id: 'exByqGILR',
+            name: 'Gym Class Booking',
+            slices: [
+              {
+                type: 'command',
+                name: 'Book Gym Class',
+                id: 'iEg3Qjbbp',
+                client: { specs: [] },
+                server: {
+                  description: '',
+                  specs: [
+                    {
+                      type: 'gherkin',
+                      feature: '',
+                      rules: [
+                        {
+                          id: 'c7TfHiadX',
+                          name: 'Class booking process',
+                          examples: [
+                            {
+                              id: '3MoVhLhAU',
+                              name: 'Book a class',
+                              steps: [
+                                {
+                                  id: 'HVYnJHNCl',
+                                  keyword: 'When',
+                                  text: 'BookGymClass',
+                                  docString: { memberId: 'mem_123', classId: 'cls_456', date: '2023-10-15' },
+                                },
+                                {
+                                  id: 'FuS1S7AMA',
+                                  keyword: 'Then',
+                                  text: 'ClassReservationConfirmed',
+                                  docString: {
+                                    reservationId: 'res_789',
+                                    memberId: 'mem_123',
+                                    classId: 'cls_456',
+                                    date: '2023-10-15',
+                                  },
+                                },
+                              ],
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                  data: {
+                    items: [
+                      {
+                        target: { type: 'Event', name: 'ClassReservationConfirmed' },
+                        destination: { type: 'stream', pattern: 'reservations' },
+                      },
+                    ],
+                  },
+                },
+              },
+            ],
+            sourceFile: '/narratives/untitled-1.narrative.ts',
+          },
+          {
+            id: 'o0odruqZA',
+            name: 'Gym Check-In',
+            slices: [
+              {
+                type: 'command',
+                name: 'Perform Check-In',
+                id: 'Cxl4UHfbX',
+                client: { specs: [] },
+                server: {
+                  description: '',
+                  specs: [
+                    {
+                      type: 'gherkin',
+                      feature: '',
+                      rules: [
+                        {
+                          id: 'n81cBIt30',
+                          name: 'Check-in process',
+                          examples: [
+                            {
+                              id: 'QiMaBqctq',
+                              name: 'Record check-in',
+                              steps: [
+                                {
+                                  id: 'Pkcushx04',
+                                  keyword: 'When',
+                                  text: 'PerformCheckIn',
+                                  docString: { memberId: 'mem_123', dateTime: '2023-10-15T08:00:00Z' },
+                                },
+                                {
+                                  id: 'Z8Ef9Yo2R',
+                                  keyword: 'Then',
+                                  text: 'CheckInRecorded',
+                                  docString: {
+                                    checkInId: 'chk_123',
+                                    memberId: 'mem_123',
+                                    dateTime: '2023-10-15T08:00:00Z',
+                                  },
+                                },
+                              ],
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                  data: {
+                    items: [
+                      {
+                        target: { type: 'Event', name: 'CheckInRecorded' },
+                        destination: { type: 'stream', pattern: 'checkins' },
+                      },
+                    ],
+                  },
+                },
+              },
+            ],
+            sourceFile: '/narratives/untitled-1-2.narrative.ts',
+          },
+        ],
+        messages: [
+          { type: 'command', name: 'SubmitMembershipRegistration', fields: [] },
+          { type: 'command', name: 'BookGymClass', fields: [] },
+          { type: 'command', name: 'PerformCheckIn', fields: [] },
+          { type: 'event', name: 'MemberAccountCreated', fields: [], source: 'internal' },
+          { type: 'event', name: 'ClassReservationConfirmed', fields: [], source: 'internal' },
+          { type: 'event', name: 'CheckInRecorded', fields: [], source: 'internal' },
+        ],
+        modules: [],
+      };
+
+      const result = await modelToNarrative(gymModel);
+
+      // Should generate 3 files, one for each narrative
+      expect(result.files.length).toBe(3);
+
+      // Check file paths match the sourceFile from each narrative
+      const filePaths = result.files.map((f) => f.path);
+      expect(filePaths).toContain('/narratives/gym.narrative.ts');
+      expect(filePaths).toContain('/narratives/untitled-1.narrative.ts');
+      expect(filePaths).toContain('/narratives/untitled-1-2.narrative.ts');
+
+      // Verify each narrative has proper content
+      const code = getCode(result);
+      expect(code).toContain("narrative('Gym Membership Registration'");
+      expect(code).toContain("narrative('Gym Class Booking'");
+      expect(code).toContain("narrative('Gym Check-In'");
+
+      // Check slices are generated for each narrative
+      expect(code).toContain("command('Register New Member'");
+      expect(code).toContain("command('Book Gym Class'");
+      expect(code).toContain("command('Perform Check-In'");
+    });
+  });
+
+  it('generates all declared types for authored modules regardless of usage analysis', async () => {
+    const model: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          id: 'narrative-1',
+          name: 'Gym Goal Setting',
+          slices: [
+            {
+              type: 'command',
+              name: 'Set Fitness Goal',
+              client: { specs: [] },
+              server: {
+                description: 'Set a fitness goal',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Goal Setting',
+                    rules: [
+                      {
+                        name: 'Create goal',
+                        examples: [
+                          {
+                            name: 'Create fitness goal',
+                            steps: [
+                              { keyword: 'When', text: 'SetFitnessGoal', docString: { name: 'Lose weight' } },
+                              { keyword: 'Then', text: 'FitnessGoalCreated', docString: { goalId: '123' } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+          sourceFile: '/narratives/goal-setting.narrative.ts',
+        },
+      ],
+      messages: [
+        { type: 'command', name: 'SetFitnessGoal', fields: [] },
+        { type: 'event', name: 'FitnessGoalCreated', fields: [], source: 'internal' },
+        { type: 'state', name: 'FitnessGoalsView', fields: [] },
+      ],
+      modules: [
+        {
+          sourceFile: '/narratives/goal-setting.narrative.ts',
+          isDerived: false,
+          contains: { narrativeIds: ['narrative-1'] },
+          declares: {
+            messages: [
+              { kind: 'command', name: 'SetFitnessGoal' },
+              { kind: 'event', name: 'FitnessGoalCreated' },
+              { kind: 'state', name: 'FitnessGoalsView' },
+            ],
+          },
+        },
+      ],
+    };
+
+    const result = await modelToNarrative(model);
+    const code = getCode(result);
+
+    // All 3 declared types should be generated
+    expect(code).toContain("type SetFitnessGoal = Command<'SetFitnessGoal'");
+    expect(code).toContain("type FitnessGoalCreated = Event<'FitnessGoalCreated'");
+    expect(code).toContain("type FitnessGoalsView = State<'FitnessGoalsView'");
   });
 });

package/src/transformers/model-to-narrative/ast/emit-helpers.ts

@@ -29,6 +29,9 @@ export function jsonToExpr(
     case 'string':
       return f.createStringLiteral(v);
     case 'number':
+      if (v < 0) {
+        return f.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, f.createNumericLiteral(String(Math.abs(v))));
+      }
       return f.createNumericLiteral(String(v));
     case 'boolean':
       return v ? f.createTrue() : f.createFalse();

package/src/transformers/model-to-narrative/generators/gwt.specs.ts

@@ -122,6 +122,31 @@ describe('buildGwtSpecBlock', () => {
 
     expect(code).toMatch(/rule\([^)]+\)\s*=>/);
   });
+
+  it('handles negative numbers in example data', () => {
+    const gwtBlock: GWTBlock & { ruleDescription: string; exampleDescription: string; ruleId: string } = {
+      when: {
+        commandRef: 'AdjustBalance',
+        exampleData: { accountId: 'acc-001', amount: -100, adjustment: -50.5 },
+      },
+      then: [
+        {
+          eventRef: 'BalanceAdjusted',
+          exampleData: { accountId: 'acc-001', newBalance: -150.5, change: -100 },
+        },
+      ],
+      ruleDescription: 'balance can be adjusted with negative amounts',
+      exampleDescription: 'adjusts balance with negative values',
+      ruleId: 'rNegNum01',
+    };
+
+    const result = buildGwtSpecBlock(ts, ts.factory, gwtBlock, 'command');
+    const code = printNode(result);
+
+    expect(code).toContain('-100');
+    expect(code).toContain('-50.5');
+    expect(code).toContain('-150.5');
+  });
 });
 
 describe('buildConsolidatedGwtSpecBlock', () => {

package/src/transformers/model-to-narrative/generators/module-code.ts

@@ -102,13 +102,22 @@ function generateModuleCode(
 
   const usedMessages = messages.filter((msg) => {
     const isImportedFromIntegration = usedTypeIntegrationNames.includes(msg.name);
-    const isUsedInFlow = usageAnalysis.usedTypes.has(msg.name);
-    const hasEmptyFlowSlices = narratives.length === 0 || narratives.every((flow) => flow.slices.length === 0);
 
+    // Don't generate local definitions for types imported from integrations
     if (isImportedFromIntegration) {
       return false;
     }
 
+    // For authored modules, trust the declares list - all declared messages should be generated
+    // (messages is already filtered to only include declared messages at line 60-61)
+    if (!module.isDerived) {
+      return true;
+    }
+
+    // For derived modules, only include types that are actually used in flow code
+    // or when there's no flow code (hasEmptyFlowSlices)
+    const isUsedInFlow = usageAnalysis.usedTypes.has(msg.name);
+    const hasEmptyFlowSlices = narratives.length === 0 || narratives.every((flow) => flow.slices.length === 0);
     return isUsedInFlow || hasEmptyFlowSlices;
   });