@auto-engineer/narrative 1.129.0 → 1.131.0

package/package.json

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

package/src/transformers/narrative-to-model/index.ts

@@ -8,7 +8,7 @@ import { inlineAllMessageFieldTypes } from './inlining';
 import { extractMessagesFromIntegrations, processDataItemIntegrations } from './integrations';
 import { processGiven, processThen, processWhen } from './spec-processors';
 import { matchesNarrativePattern } from './strings';
-import { resolveInferredType } from './type-inference';
+import { buildTypeInfoFromMessages, resolveInferredType } from './type-inference';
 
 type TypeResolver = (
   t: string,
@@ -107,25 +107,34 @@ function tryResolveFromUnionTypes(
 function createTypeResolver(
   narrativeSpecificTypes: Map<string, TypeInfo> | undefined,
   unionTypes: Map<string, TypeInfo> | undefined,
+  messages: Map<string, Message>,
 ) {
   return (
     t: string,
     expected?: 'command' | 'event' | 'state' | 'query',
     exampleData?: unknown,
   ): { resolvedName: string; typeInfo: TypeInfo | undefined } => {
+    let result: { resolvedName: string; typeInfo: TypeInfo | undefined } | undefined;
+
     if (narrativeSpecificTypes) {
-      const result = tryResolveFromNarrativeTypes(t, narrativeSpecificTypes, expected, exampleData);
-      if (unionTypes) {
-        return tryFallbackToUnionTypes(t, result.resolvedName, result.typeInfo, unionTypes, expected, exampleData);
-      }
+      const nr = tryResolveFromNarrativeTypes(t, narrativeSpecificTypes, expected, exampleData);
+      result = unionTypes
+        ? tryFallbackToUnionTypes(t, nr.resolvedName, nr.typeInfo, unionTypes, expected, exampleData)
+        : nr;
+    } else if (unionTypes) {
+      result = tryResolveFromUnionTypes(t, unionTypes, expected, exampleData);
+    }
+
+    if (result && result.resolvedName !== 'InferredType') {
       return result;
     }
 
-    if (unionTypes) {
-      return tryResolveFromUnionTypes(t, unionTypes, expected, exampleData);
+    const messagesTypeMap = buildTypeInfoFromMessages(messages);
+    if (messagesTypeMap) {
+      return tryResolveFromUnionTypes(t, messagesTypeMap, expected, exampleData);
     }
 
-    return { resolvedName: t, typeInfo: undefined };
+    return result ?? { resolvedName: t, typeInfo: undefined };
   };
 }
 
@@ -272,7 +281,7 @@ function processNarrative(
   exampleShapeHints: ExampleShapeHints,
 ): void {
   const narrativeSpecificTypes = getNarrativeSpecificTypes(flow);
-  const resolveTypeAndInfo = createTypeResolver(narrativeSpecificTypes, unionTypes);
+  const resolveTypeAndInfo = createTypeResolver(narrativeSpecificTypes, unionTypes, messages);
 
   flow.slices.forEach((slice: Narrative['slices'][number]) => {
     processSliceSpecs(slice, resolveTypeAndInfo, messages, exampleShapeHints);

package/src/transformers/narrative-to-model/type-inference.specs.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import type { Narrative } from '../../index';
+import type { Message, Narrative } from '../../index';
 import { narrativesToModel } from './index';
+import { buildTypeInfoFromMessages, messageToTypeInfo } from './type-inference';
 
 describe('Type inference in narrative-to-model transformer', () => {
   it('should correctly extract command types from when clauses', () => {
@@ -184,3 +185,158 @@ describe('Type inference in narrative-to-model transformer', () => {
     expect(model.messages.some((msg) => msg.name === 'InferredType')).toBe(false);
   });
 });
+
+describe('Messages-derived fallback in type resolution', () => {
+  it('resolves InferredType in second example When step via messages populated by first example', () => {
+    const flows: Narrative[] = [
+      {
+        name: 'Booking Flow',
+        id: 'FLOW-001',
+        slices: [
+          {
+            id: 'SLICE-001',
+            type: 'command',
+            name: 'Request Booking',
+            client: { specs: [] },
+            server: {
+              description: 'Request booking server',
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Request Booking Specs',
+                  rules: [
+                    {
+                      id: 'RULE-001',
+                      name: 'Happy path',
+                      examples: [
+                        {
+                          name: 'Room available',
+                          steps: [
+                            {
+                              keyword: 'When',
+                              text: 'RequestBooking',
+                              docString: { guestId: 'g-1', roomType: 'suite' },
+                            },
+                            {
+                              keyword: 'Then',
+                              text: 'BookingRequested',
+                              docString: { guestId: 'g-1', roomType: 'suite' },
+                            },
+                          ],
+                        },
+                        {
+                          name: 'Capacity exceeded',
+                          steps: [
+                            {
+                              keyword: 'When',
+                              text: 'InferredType',
+                              docString: { guestId: 'g-2', roomType: 'double' },
+                            },
+                            {
+                              keyword: 'Then',
+                              text: 'BookingDenied',
+                              docString: { guestId: 'g-2', reason: 'no availability' },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ];
+
+    const model = narrativesToModel(flows);
+
+    expect(model.messages.some((msg) => msg.name === 'InferredType')).toBe(false);
+    expect(model.messages.some((msg) => msg.name === 'RequestBooking')).toBe(true);
+    expect(model.messages.some((msg) => msg.name === 'BookingRequested')).toBe(true);
+    expect(model.messages.some((msg) => msg.name === 'BookingDenied')).toBe(true);
+  });
+});
+
+describe('messageToTypeInfo', () => {
+  it('converts a Message to TypeInfo with correct field mapping', () => {
+    const msg: Message = {
+      name: 'RequestBooking',
+      type: 'command',
+      fields: [
+        { name: 'guestId', type: 'string', required: true },
+        { name: 'roomType', type: 'string', required: false },
+      ],
+    };
+
+    const result = messageToTypeInfo(msg);
+
+    expect(result).toEqual({
+      stringLiteral: 'RequestBooking',
+      classification: 'command',
+      dataFields: [
+        { name: 'guestId', type: 'string', required: true },
+        { name: 'roomType', type: 'string', required: false },
+      ],
+    });
+  });
+});
+
+describe('buildTypeInfoFromMessages', () => {
+  it('returns undefined for an empty messages map', () => {
+    const messages = new Map<string, Message>();
+
+    expect(buildTypeInfoFromMessages(messages)).toEqual(undefined);
+  });
+
+  it('builds a TypeInfo map from a populated messages map', () => {
+    const messages = new Map<string, Message>([
+      [
+        'RequestBooking',
+        {
+          name: 'RequestBooking',
+          type: 'command',
+          fields: [{ name: 'guestId', type: 'string', required: true }],
+        },
+      ],
+      [
+        'BookingRequested',
+        {
+          name: 'BookingRequested',
+          type: 'event',
+          fields: [
+            { name: 'guestId', type: 'string', required: true },
+            { name: 'bookedAt', type: 'Date', required: true },
+          ],
+        },
+      ],
+    ]);
+
+    const result = buildTypeInfoFromMessages(messages);
+
+    expect(result).toEqual(
+      new Map([
+        [
+          'RequestBooking',
+          {
+            stringLiteral: 'RequestBooking',
+            classification: 'command',
+            dataFields: [{ name: 'guestId', type: 'string', required: true }],
+          },
+        ],
+        [
+          'BookingRequested',
+          {
+            stringLiteral: 'BookingRequested',
+            classification: 'event',
+            dataFields: [
+              { name: 'guestId', type: 'string', required: true },
+              { name: 'bookedAt', type: 'Date', required: true },
+            ],
+          },
+        ],
+      ]),
+    );
+  });
+});

package/src/transformers/narrative-to-model/type-inference.ts

@@ -1,4 +1,5 @@
 import type { TypeInfo } from '../../loader/ts-utils';
+import type { Message } from '../../schema';
 
 function tryDataFieldMatch(typeInfo: TypeInfo, dataKeys: Set<string>): boolean {
   const dataField = typeInfo.dataFields?.find((f) => f.name === 'data');
@@ -125,3 +126,20 @@ export function resolveInferredType(
   const resolved = resolveFromCandidates(candidates, all, expectedMessageType, exampleData);
   return resolved ?? typeName;
 }
+
+export function messageToTypeInfo(msg: Message): TypeInfo {
+  return {
+    stringLiteral: msg.name,
+    classification: msg.type,
+    dataFields: msg.fields.map((f) => ({ name: f.name, type: f.type, required: f.required })),
+  };
+}
+
+export function buildTypeInfoFromMessages(messages: Map<string, Message>): Map<string, TypeInfo> | undefined {
+  if (messages.size === 0) return undefined;
+  const map = new Map<string, TypeInfo>();
+  for (const [name, msg] of messages) {
+    map.set(name, messageToTypeInfo(msg));
+  }
+  return map;
+}