@auto-engineer/narrative 1.139.0 → 1.140.1

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

@@ -20,7 +20,7 @@ export type { GeneratedFile };
 
 export function generateAllModulesCode(model: Model, opts: GenerateModuleCodeOptions): GeneratedFile[] {
   const modules =
-    model.modules && model.modules.length > 0 ? model.modules : deriveModules(model.narratives, model.messages);
+    model.modules && model.modules.length > 0 ? model.modules : deriveModules(model.scenes, model.messages);
 
   // Compute all cross-module dependencies in a single pass
   const { importsPerModule, exportsPerModule } = computeAllCrossModuleDependencies(modules, model);
@@ -40,16 +40,16 @@ export function generateAllModulesCode(model: Model, opts: GenerateModuleCodeOpt
   return sortFilesByPath(files);
 }
 
-function getNarrativesForModule(module: Module, model: Model): Model['narratives'] {
+function getScenesForModule(module: Module, model: Model): Model['scenes'] {
   if (module.isDerived) {
-    return model.narratives.filter((n) => {
-      const narrativeSourceFile = n.sourceFile ?? 'generated.narrative.ts';
-      return narrativeSourceFile === module.sourceFile;
+    return model.scenes.filter((n) => {
+      const sceneSourceFile = n.sourceFile ?? 'generated.narrative.ts';
+      return sceneSourceFile === module.sourceFile;
     });
   }
 
-  const narrativeIds = new Set(module.contains.narrativeIds);
-  return model.narratives.filter((n) => n.id && narrativeIds.has(n.id));
+  const sceneIds = new Set(module.contains.sceneIds);
+  return model.scenes.filter((n) => n.id && sceneIds.has(n.id));
 }
 
 function generateModuleCode(
@@ -61,12 +61,12 @@ function generateModuleCode(
 ): string {
   const f = ts.factory;
 
-  const narratives = getNarrativesForModule(module, model);
+  const scenes = getScenesForModule(module, model);
   const declaredMessageKeys = new Set(module.declares.messages.map((m) => `${m.kind}:${m.name}`));
   const messages = model.messages.filter((m) => declaredMessageKeys.has(`${m.type}:${m.name}`));
   const integrations = model.integrations ?? [];
 
-  const allTypeIntegrationNames = extractTypeIntegrationNames(narratives);
+  const allTypeIntegrationNames = extractTypeIntegrationNames(scenes);
   const allValueIntegrationNames = integrations.map((integration) => integrationNameToPascalCase(integration.name));
 
   const allFlowFunctionNames = [...ALL_FLOW_FUNCTION_NAMES];
@@ -77,7 +77,7 @@ function generateModuleCode(
     allTypeIntegrationNames,
     allValueIntegrationNames,
     allFlowFunctionNames,
-    narratives,
+    scenes,
     [],
   );
   const preliminaryFile = f.createSourceFile(
@@ -120,10 +120,10 @@ function generateModuleCode(
     }
 
     // For derived modules, only include types that are actually used in flow code
-    // or when there's no flow code (hasEmptyFlowSlices)
+    // or when there's no flow code (hasEmptyFlowMoments)
     const isUsedInFlow = usageAnalysis.usedTypes.has(msg.name);
-    const hasEmptyFlowSlices = narratives.length === 0 || narratives.every((flow) => flow.slices.length === 0);
-    return isUsedInFlow || hasEmptyFlowSlices;
+    const hasEmptyFlowMoments = scenes.length === 0 || scenes.every((flow) => flow.moments.length === 0);
+    return isUsedInFlow || hasEmptyFlowMoments;
   });
 
   const statements = buildStatements(
@@ -133,7 +133,7 @@ function generateModuleCode(
     usedTypeIntegrationNames,
     usedValueIntegrationNames,
     usedFlowFunctionNames,
-    narratives,
+    scenes,
     crossModuleImports,
     exportedTypes,
   );
@@ -150,7 +150,7 @@ function buildStatements(
   typeIntegrationNames: string[],
   valueIntegrationNames: string[],
   usedFlowFunctionNames: string[],
-  flows: Model['narratives'],
+  flows: Model['scenes'],
   crossModuleImports: CrossModuleImport[],
   exportedTypes?: Set<string>,
 ): ts.Statement[] {

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

@@ -1,7 +1,7 @@
 import type { Model } from '../../index';
 import { formatWithPrettier } from './formatting/prettier';
 import { generateAllModulesCode } from './generators/module-code';
-import type { GeneratedNarratives } from './types';
+import type { GeneratedScenes } from './types';
 
 /**
  * Converts a schema specification to TypeScript flow DSL code files.
@@ -11,9 +11,9 @@ import type { GeneratedNarratives } from './types';
  * and flow specifications. Each module in the model produces one output file.
  *
  * @param model The complete schema specification conforming to SpecsSchema
- * @returns Promise resolving to GeneratedNarratives with files array
+ * @returns Promise resolving to GeneratedScenes with files array
  */
-export async function modelToNarrative(model: Model): Promise<GeneratedNarratives> {
+export async function modelToNarrative(model: Model): Promise<GeneratedScenes> {
   const flowImport = '@auto-engineer/narrative';
   const integrationImport = extractIntegrationImportFromModel(model);
 
@@ -36,4 +36,4 @@ function extractIntegrationImportFromModel(model: Model): string {
   return '';
 }
 
-export type { GeneratedNarratives } from './types';
+export type { GeneratedScenes } from './types';

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

@@ -8,18 +8,18 @@ describe('module functionality', () => {
     it('produces self-contained files with duplicated types for each sourceFile', async () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Orders',
             id: 'orders-flow',
             sourceFile: 'orders.narrative.ts',
-            slices: [],
+            moments: [],
           },
           {
             name: 'Users',
             id: 'users-flow',
             sourceFile: 'users.narrative.ts',
-            slices: [],
+            moments: [],
           },
         ],
         messages: [
@@ -35,13 +35,13 @@ describe('module functionality', () => {
           {
             sourceFile: 'orders.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['orders-flow'] },
+            contains: { sceneIds: ['orders-flow'] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
           {
             sourceFile: 'users.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['users-flow'] },
+            contains: { sceneIds: ['users-flow'] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
         ],
@@ -73,16 +73,16 @@ describe('module functionality', () => {
     it('generates cross-module imports for types declared by other modules', async () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Shared Types',
             id: 'shared-types',
-            slices: [],
+            moments: [],
           },
           {
             name: 'Orders',
             id: 'orders-flow',
-            slices: [
+            moments: [
               {
                 name: 'create order',
                 type: 'command',
@@ -132,7 +132,7 @@ describe('module functionality', () => {
           {
             sourceFile: 'shared/types.narrative.ts',
             isDerived: false,
-            contains: { narrativeIds: ['shared-types'] },
+            contains: { sceneIds: ['shared-types'] },
             declares: {
               messages: [{ kind: 'event', name: 'OrderCreated' }],
             },
@@ -140,7 +140,7 @@ describe('module functionality', () => {
           {
             sourceFile: 'features/orders.narrative.ts',
             isDerived: false,
-            contains: { narrativeIds: ['orders-flow'] },
+            contains: { sceneIds: ['orders-flow'] },
             declares: {
               messages: [{ kind: 'command', name: 'CreateOrder' }],
             },
@@ -166,19 +166,19 @@ describe('module functionality', () => {
     it('detects duplicate sourceFiles', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [],
+        scenes: [],
         messages: [],
         modules: [
           {
             sourceFile: 'same-file.ts',
             isDerived: false,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [] },
           },
           {
             sourceFile: 'same-file.ts',
             isDerived: false,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [] },
           },
         ],
@@ -194,19 +194,19 @@ describe('module functionality', () => {
     it('detects narrative assigned to multiple authored modules', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [{ name: 'Test', id: 'test-narrative', slices: [] }],
+        scenes: [{ name: 'Test', id: 'test-narrative', moments: [] }],
         messages: [],
         modules: [
           {
             sourceFile: 'a.ts',
             isDerived: false,
-            contains: { narrativeIds: ['test-narrative'] },
+            contains: { sceneIds: ['test-narrative'] },
             declares: { messages: [] },
           },
           {
             sourceFile: 'b.ts',
             isDerived: false,
-            contains: { narrativeIds: ['test-narrative'] },
+            contains: { sceneIds: ['test-narrative'] },
             declares: { messages: [] },
           },
         ],
@@ -214,25 +214,25 @@ describe('module functionality', () => {
 
       const errors = validateModules(model);
 
-      expect(errors.some((e) => e.type === 'narrative_multi_assigned')).toBe(true);
+      expect(errors.some((e) => e.type === 'scene_multi_assigned')).toBe(true);
     });
 
     it('detects message declared by multiple authored modules', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [],
+        scenes: [],
         messages: [{ type: 'event', source: 'internal', name: 'SharedEvent', fields: [] }],
         modules: [
           {
             sourceFile: 'a.ts',
             isDerived: false,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
           {
             sourceFile: 'b.ts',
             isDerived: false,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
         ],
@@ -246,19 +246,19 @@ describe('module functionality', () => {
     it('allows type duplication in derived modules', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [],
+        scenes: [],
         messages: [{ type: 'event', source: 'internal', name: 'SharedEvent', fields: [] }],
         modules: [
           {
             sourceFile: 'file1.ts',
             isDerived: true,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
           {
             sourceFile: 'file2.ts',
             isDerived: true,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
         ],
@@ -272,7 +272,7 @@ describe('module functionality', () => {
     it('returns no errors for empty modules array', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [{ name: 'Test', id: 'test-1', slices: [] }],
+        scenes: [{ name: 'Test', id: 'test-1', moments: [] }],
         messages: [{ type: 'event', source: 'internal', name: 'TestEvent', fields: [] }],
         modules: [],
       };
@@ -285,13 +285,13 @@ describe('module functionality', () => {
     it('detects narrative not found in model', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [],
+        scenes: [],
         messages: [],
         modules: [
           {
             sourceFile: 'a.ts',
             isDerived: false,
-            contains: { narrativeIds: ['nonexistent-narrative'] },
+            contains: { sceneIds: ['nonexistent-narrative'] },
             declares: { messages: [] },
           },
         ],
@@ -299,20 +299,20 @@ describe('module functionality', () => {
 
       const errors = validateModules(model);
 
-      expect(errors.some((e) => e.type === 'narrative_not_found')).toBe(true);
+      expect(errors.some((e) => e.type === 'scene_not_found')).toBe(true);
       expect(errors[0].message).toContain('nonexistent-narrative');
     });
 
-    it('detects unassigned narratives', () => {
+    it('detects unassigned scenes', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [{ name: 'Orphan', id: 'orphan-narrative', slices: [] }],
+        scenes: [{ name: 'Orphan', id: 'orphan-narrative', moments: [] }],
         messages: [],
         modules: [
           {
             sourceFile: 'a.ts',
             isDerived: false,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [] },
           },
         ],
@@ -320,20 +320,20 @@ describe('module functionality', () => {
 
       const errors = validateModules(model);
 
-      expect(errors.some((e) => e.type === 'narrative_unassigned')).toBe(true);
-      expect(errors.find((e) => e.type === 'narrative_unassigned')!.message).toContain('orphan-narrative');
+      expect(errors.some((e) => e.type === 'scene_unassigned')).toBe(true);
+      expect(errors.find((e) => e.type === 'scene_unassigned')!.message).toContain('orphan-narrative');
     });
 
     it('detects undeclared messages', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [],
+        scenes: [],
         messages: [{ type: 'event', source: 'internal', name: 'UndeclaredEvent', fields: [] }],
         modules: [
           {
             sourceFile: 'a.ts',
             isDerived: false,
-            contains: { narrativeIds: [] },
+            contains: { sceneIds: [] },
             declares: { messages: [] },
           },
         ],
@@ -361,18 +361,18 @@ describe('module functionality', () => {
     it('generates separate files for each sourceFile in derived modules', async () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Orders',
             id: 'orders-flow',
             sourceFile: 'orders.narrative.ts',
-            slices: [],
+            moments: [],
           },
           {
             name: 'Users',
             id: 'users-flow',
             sourceFile: 'users.narrative.ts',
-            slices: [],
+            moments: [],
           },
         ],
         messages: [
@@ -389,7 +389,7 @@ describe('module functionality', () => {
           {
             sourceFile: 'orders.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['orders-flow'] },
+            contains: { sceneIds: ['orders-flow'] },
             declares: {
               messages: [
                 { kind: 'command', name: 'CreateOrder' },
@@ -400,7 +400,7 @@ describe('module functionality', () => {
           {
             sourceFile: 'users.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['users-flow'] },
+            contains: { sceneIds: ['users-flow'] },
             declares: {
               messages: [
                 { kind: 'command', name: 'CreateOrder' },
@@ -419,16 +419,16 @@ describe('module functionality', () => {
       const ordersFile = result.files.find((f) => f.path === 'orders.narrative.ts');
       const usersFile = result.files.find((f) => f.path === 'users.narrative.ts');
 
-      expect(ordersFile?.code).toContain("narrative('Orders'");
-      expect(usersFile?.code).toContain("narrative('Users'");
+      expect(ordersFile?.code).toContain("scene('Orders'");
+      expect(usersFile?.code).toContain("scene('Users'");
     });
 
     it('duplicates types in each derived module file', async () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
-          { name: 'Flow A', id: 'flow-a', sourceFile: 'a.narrative.ts', slices: [] },
-          { name: 'Flow B', id: 'flow-b', sourceFile: 'b.narrative.ts', slices: [] },
+        scenes: [
+          { name: 'Flow A', id: 'flow-a', sourceFile: 'a.narrative.ts', moments: [] },
+          { name: 'Flow B', id: 'flow-b', sourceFile: 'b.narrative.ts', moments: [] },
         ],
         messages: [
           {
@@ -443,13 +443,13 @@ describe('module functionality', () => {
           {
             sourceFile: 'a.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['flow-a'] },
+            contains: { sceneIds: ['flow-a'] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
           {
             sourceFile: 'b.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['flow-b'] },
+            contains: { sceneIds: ['flow-b'] },
             declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
           },
         ],
@@ -465,12 +465,12 @@ describe('module functionality', () => {
     it('generates cross-module imports for authored modules', async () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
-          { name: 'Shared Types', id: 'shared-types', slices: [] },
+        scenes: [
+          { name: 'Shared Types', id: 'shared-types', moments: [] },
           {
             name: 'Orders',
             id: 'orders-flow',
-            slices: [
+            moments: [
               {
                 name: 'create order',
                 type: 'command',
@@ -516,13 +516,13 @@ describe('module functionality', () => {
           {
             sourceFile: 'shared/types.narrative.ts',
             isDerived: false,
-            contains: { narrativeIds: ['shared-types'] },
+            contains: { sceneIds: ['shared-types'] },
             declares: { messages: [{ kind: 'event', name: 'OrderCreated' }] },
           },
           {
             sourceFile: 'features/orders.narrative.ts',
             isDerived: false,
-            contains: { narrativeIds: ['orders-flow'] },
+            contains: { sceneIds: ['orders-flow'] },
             declares: { messages: [{ kind: 'command', name: 'CreateOrder' }] },
           },
         ],
@@ -543,10 +543,10 @@ describe('module functionality', () => {
     it('sorts output files alphabetically by path', async () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
-          { name: 'Z', id: 'z', sourceFile: 'z.narrative.ts', slices: [] },
-          { name: 'A', id: 'a', sourceFile: 'a.narrative.ts', slices: [] },
-          { name: 'M', id: 'm', sourceFile: 'm.narrative.ts', slices: [] },
+        scenes: [
+          { name: 'Z', id: 'z', sourceFile: 'z.narrative.ts', moments: [] },
+          { name: 'A', id: 'a', sourceFile: 'a.narrative.ts', moments: [] },
+          { name: 'M', id: 'm', sourceFile: 'm.narrative.ts', moments: [] },
         ],
         messages: [],
         integrations: [],
@@ -554,19 +554,19 @@ describe('module functionality', () => {
           {
             sourceFile: 'z.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['z'] },
+            contains: { sceneIds: ['z'] },
             declares: { messages: [] },
           },
           {
             sourceFile: 'a.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['a'] },
+            contains: { sceneIds: ['a'] },
             declares: { messages: [] },
           },
           {
             sourceFile: 'm.narrative.ts',
             isDerived: true,
-            contains: { narrativeIds: ['m'] },
+            contains: { sceneIds: ['m'] },
             declares: { messages: [] },
           },
         ],