@auto-engineer/narrative 1.5.1 → 1.5.2

package/package.json

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

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

@@ -7,14 +7,6 @@ export interface FieldTypeInfo {
   [fieldName: string]: string; // field name -> type (e.g., 'Date', 'string', etc.)
 }
 
-/**
- * Check if a string is a valid ISO date string
- */
-function isISODateString(str: string): boolean {
-  const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})?$/;
-  return isoDateRegex.test(str);
-}
-
 /**
  * Emit a TS expression from a plain JSON-like value with optional type information for Date handling.
  */
@@ -50,7 +42,7 @@ export function jsonToExpr(
           const fieldType = typeInfo?.[k];
           let valueExpr: tsNS.Expression;
 
-          if (fieldType === 'Date' && typeof x === 'string' && isISODateString(x)) {
+          if (fieldType === 'Date' && typeof x === 'string') {
             // Generate new Date('...') for Date fields
             valueExpr = f.createNewExpression(f.createIdentifier('Date'), undefined, [f.createStringLiteral(x)]);
           } else if (fieldType === 'Date' && x instanceof Date) {

package/src/transformers/model-to-narrative/cross-module-imports.specs.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from 'vitest';
 import type { Model } from '../../index';
-import { computeCrossModuleImports, resolveRelativeImport } from './cross-module-imports';
+import {
+  computeAllCrossModuleDependencies,
+  computeCrossModuleImports,
+  resolveRelativeImport,
+} from './cross-module-imports';
 
 describe('resolveRelativeImport', () => {
   it('resolves same directory imports', () => {
@@ -49,7 +53,6 @@ describe('computeCrossModuleImports', () => {
       integrations: [],
       modules: [
         {
-          id: 'derived.ts',
           sourceFile: 'derived.ts',
           isDerived: true,
           contains: { narrativeIds: [] },
@@ -103,7 +106,6 @@ describe('computeCrossModuleImports', () => {
       integrations: [],
       modules: [
         {
-          id: 'self-contained',
           sourceFile: 'self-contained.ts',
           isDerived: false,
           contains: { narrativeIds: ['test-1'] },
@@ -157,7 +159,6 @@ describe('computeCrossModuleImports', () => {
       integrations: [],
       modules: [
         {
-          id: 'consumer',
           sourceFile: 'consumer.ts',
           isDerived: false,
           contains: { narrativeIds: ['test-1'] },
@@ -212,14 +213,12 @@ describe('computeCrossModuleImports', () => {
       integrations: [],
       modules: [
         {
-          id: 'shared',
           sourceFile: 'shared/types.ts',
           isDerived: false,
           contains: { narrativeIds: ['shared-1'] },
           declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
         },
         {
-          id: 'consumer',
           sourceFile: 'features/consumer.ts',
           isDerived: false,
           contains: { narrativeIds: ['consumer-1'] },
@@ -281,7 +280,6 @@ describe('computeCrossModuleImports', () => {
       integrations: [],
       modules: [
         {
-          id: 'shared',
           sourceFile: 'shared.ts',
           isDerived: false,
           contains: { narrativeIds: ['shared-1'] },
@@ -293,7 +291,6 @@ describe('computeCrossModuleImports', () => {
           },
         },
         {
-          id: 'consumer',
           sourceFile: 'consumer.ts',
           isDerived: false,
           contains: { narrativeIds: ['consumer-1'] },
@@ -349,14 +346,12 @@ describe('computeCrossModuleImports', () => {
       integrations: [],
       modules: [
         {
-          id: 'derived.ts',
           sourceFile: 'derived.ts',
           isDerived: true,
           contains: { narrativeIds: [] },
           declares: { messages: [{ kind: 'event', name: 'DerivedEvent' }] },
         },
         {
-          id: 'consumer',
           sourceFile: 'consumer.ts',
           isDerived: false,
           contains: { narrativeIds: ['consumer-1'] },
@@ -419,21 +414,18 @@ describe('computeCrossModuleImports', () => {
       integrations: [],
       modules: [
         {
-          id: 'z-types',
           sourceFile: 'z-types.ts',
           isDerived: false,
           contains: { narrativeIds: ['types-1'] },
           declares: { messages: [{ kind: 'event', name: 'ZEvent' }] },
         },
         {
-          id: 'a-types',
           sourceFile: 'a-types.ts',
           isDerived: false,
           contains: { narrativeIds: ['types-2'] },
           declares: { messages: [{ kind: 'event', name: 'AEvent' }] },
         },
         {
-          id: 'consumer',
           sourceFile: 'consumer.ts',
           isDerived: false,
           contains: { narrativeIds: ['consumer-1'] },
@@ -448,3 +440,189 @@ describe('computeCrossModuleImports', () => {
     expect(imports.map((i) => i.fromPath)).toEqual(['./a-types', './z-types']);
   });
 });
+
+describe('computeAllCrossModuleDependencies', () => {
+  it('returns empty maps when no cross-module imports exist', () => {
+    const model: Model = {
+      variant: 'specs',
+      narratives: [{ name: 'Test', id: 'test-1', slices: [] }],
+      messages: [{ type: 'event', source: 'internal', name: 'LocalEvent', fields: [] }],
+      integrations: [],
+      modules: [
+        {
+          sourceFile: 'self-contained.ts',
+          isDerived: false,
+          contains: { narrativeIds: ['test-1'] },
+          declares: { messages: [{ kind: 'event', name: 'LocalEvent' }] },
+        },
+      ],
+    };
+
+    const { importsPerModule, exportsPerModule } = computeAllCrossModuleDependencies(model.modules, model);
+
+    expect(importsPerModule.get('self-contained.ts')).toEqual([]);
+    expect(exportsPerModule.size).toBe(0);
+  });
+
+  it('computes imports and exports in a single pass', () => {
+    const model: Model = {
+      variant: 'specs',
+      narratives: [
+        { name: 'Shared', id: 'shared-1', slices: [] },
+        {
+          name: 'Consumer',
+          id: 'consumer-1',
+          slices: [
+            {
+              name: 'test',
+              type: 'command',
+              client: { specs: [] },
+              server: {
+                description: 'Test',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Test',
+                    rules: [
+                      {
+                        name: 'rule',
+                        examples: [
+                          {
+                            name: 'example',
+                            steps: [{ keyword: 'Then', text: 'SharedEvent' }],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [{ type: 'event', source: 'internal', name: 'SharedEvent', fields: [] }],
+      integrations: [],
+      modules: [
+        {
+          sourceFile: 'shared/types.ts',
+          isDerived: false,
+          contains: { narrativeIds: ['shared-1'] },
+          declares: { messages: [{ kind: 'event', name: 'SharedEvent' }] },
+        },
+        {
+          sourceFile: 'features/consumer.ts',
+          isDerived: false,
+          contains: { narrativeIds: ['consumer-1'] },
+          declares: { messages: [] },
+        },
+      ],
+    };
+
+    const { importsPerModule, exportsPerModule } = computeAllCrossModuleDependencies(model.modules, model);
+
+    // Consumer should import SharedEvent
+    expect(importsPerModule.get('features/consumer.ts')).toEqual([
+      { fromPath: '../shared/types', typeNames: ['SharedEvent'] },
+    ]);
+
+    // Shared module should export SharedEvent
+    expect(exportsPerModule.get('shared/types.ts')).toEqual(new Set(['SharedEvent']));
+    expect(exportsPerModule.has('features/consumer.ts')).toBe(false);
+  });
+
+  it('aggregates exports from multiple importing modules', () => {
+    const model: Model = {
+      variant: 'specs',
+      narratives: [
+        { name: 'Shared', id: 'shared-1', slices: [] },
+        {
+          name: 'Consumer1',
+          id: 'consumer-1',
+          slices: [
+            {
+              name: 'test',
+              type: 'command',
+              client: { specs: [] },
+              server: {
+                description: 'Test',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Test',
+                    rules: [
+                      {
+                        name: 'rule',
+                        examples: [{ name: 'ex', steps: [{ keyword: 'Then', text: 'EventA' }] }],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+        {
+          name: 'Consumer2',
+          id: 'consumer-2',
+          slices: [
+            {
+              name: 'test',
+              type: 'command',
+              client: { specs: [] },
+              server: {
+                description: 'Test',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Test',
+                    rules: [
+                      {
+                        name: 'rule',
+                        examples: [{ name: 'ex', steps: [{ keyword: 'Then', text: 'EventB' }] }],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        { type: 'event', source: 'internal', name: 'EventA', fields: [] },
+        { type: 'event', source: 'internal', name: 'EventB', fields: [] },
+      ],
+      integrations: [],
+      modules: [
+        {
+          sourceFile: 'shared.ts',
+          isDerived: false,
+          contains: { narrativeIds: ['shared-1'] },
+          declares: {
+            messages: [
+              { kind: 'event', name: 'EventA' },
+              { kind: 'event', name: 'EventB' },
+            ],
+          },
+        },
+        {
+          sourceFile: 'consumer1.ts',
+          isDerived: false,
+          contains: { narrativeIds: ['consumer-1'] },
+          declares: { messages: [] },
+        },
+        {
+          sourceFile: 'consumer2.ts',
+          isDerived: false,
+          contains: { narrativeIds: ['consumer-2'] },
+          declares: { messages: [] },
+        },
+      ],
+    };
+
+    const { exportsPerModule } = computeAllCrossModuleDependencies(model.modules, model);
+
+    expect(exportsPerModule.get('shared.ts')).toEqual(new Set(['EventA', 'EventB']));
+  });
+});

package/src/transformers/model-to-narrative/cross-module-imports.ts

@@ -6,20 +6,91 @@ import type { CrossModuleImport } from './types';
 
 export type { CrossModuleImport };
 
+/**
+ * Computes cross-module imports for a single module.
+ * Returns the list of imports needed (with relative paths).
+ */
 export function computeCrossModuleImports(module: Module, allModules: Module[], model: Model): CrossModuleImport[] {
-  if (module.isDerived) {
+  const dependencyMap = computeModuleDependencies(module, allModules, model);
+  if (!dependencyMap) {
     return [];
   }
+  return convertToImports(module.sourceFile, dependencyMap);
+}
+
+/**
+ * Computes cross-module imports for all modules and derives which types need to be exported.
+ * Returns both the imports per module and the exports per module in a single pass.
+ */
+export function computeAllCrossModuleDependencies(
+  modules: Module[],
+  model: Model,
+): {
+  importsPerModule: Map<string, CrossModuleImport[]>;
+  exportsPerModule: Map<string, Set<string>>;
+} {
+  const importsPerModule = new Map<string, CrossModuleImport[]>();
+  const exportsPerModule = new Map<string, Set<string>>();
+
+  for (const module of modules) {
+    const dependencyMap = computeModuleDependencies(module, modules, model);
+
+    if (!dependencyMap) {
+      importsPerModule.set(module.sourceFile, []);
+      continue;
+    }
+
+    // Convert to imports with relative paths
+    importsPerModule.set(module.sourceFile, convertToImports(module.sourceFile, dependencyMap));
+
+    // Track which types need to be exported from each declaring module
+    for (const [declaringSourceFile, typeNames] of dependencyMap) {
+      if (!exportsPerModule.has(declaringSourceFile)) {
+        exportsPerModule.set(declaringSourceFile, new Set());
+      }
+      for (const typeName of typeNames) {
+        exportsPerModule.get(declaringSourceFile)!.add(typeName);
+      }
+    }
+  }
+
+  return { importsPerModule, exportsPerModule };
+}
+
+export function resolveRelativeImport(fromPath: string, toPath: string): string {
+  const fromDir = dirname(fromPath);
+  const toDir = dirname(toPath);
+  const toFile = basename(toPath, extname(toPath));
+
+  const relativePath = relative(fromDir, toDir);
+  if (relativePath === '') {
+    return `./${toFile}`;
+  }
+  if (!relativePath.startsWith('.')) {
+    return `./${relativePath}/${toFile}`;
+  }
+
+  return join(relativePath, toFile);
+}
+
+/**
+ * Core logic: computes which types a module needs from other modules.
+ * Returns a map of declaringModuleSourceFile -> typeNames[], or null if no dependencies.
+ */
+function computeModuleDependencies(module: Module, allModules: Module[], model: Model): Map<string, string[]> | null {
+  if (module.isDerived) {
+    return null;
+  }
 
   const declaredKeys = new Set(module.declares.messages.map((m) => toMessageKey(m.kind, m.name)));
   const usedKeys = collectUsedMessageKeysForModule(module, model);
   const neededKeys = new Set([...usedKeys].filter((k) => !declaredKeys.has(k)));
 
   if (neededKeys.size === 0) {
-    return [];
+    return null;
   }
 
-  const importsByModule = new Map<string, string[]>();
+  const dependencyMap = new Map<string, string[]>();
 
   for (const msgKey of neededKeys) {
     const { name } = parseMessageKey(msgKey);
@@ -27,36 +98,28 @@ export function computeCrossModuleImports(module: Module, allModules: Module[],
 
     if (declaringModule) {
       const modulePath = declaringModule.sourceFile;
-      if (!importsByModule.has(modulePath)) {
-        importsByModule.set(modulePath, []);
+      if (!dependencyMap.has(modulePath)) {
+        dependencyMap.set(modulePath, []);
       }
-      importsByModule.get(modulePath)!.push(name);
+      dependencyMap.get(modulePath)!.push(name);
     }
   }
 
-  const imports: CrossModuleImport[] = [];
-  for (const [modulePath, typeNames] of importsByModule) {
-    const relativePath = resolveRelativeImport(module.sourceFile, modulePath);
-    imports.push({ fromPath: relativePath, typeNames });
-  }
-
-  return sortImportsBySource(imports);
+  return dependencyMap.size > 0 ? dependencyMap : null;
 }
 
-export function resolveRelativeImport(fromPath: string, toPath: string): string {
-  const fromDir = dirname(fromPath);
-  const toDir = dirname(toPath);
-  const toFile = basename(toPath, extname(toPath));
+/**
+ * Converts a dependency map (absolute paths) to CrossModuleImport[] (relative paths).
+ */
+function convertToImports(fromSourceFile: string, dependencyMap: Map<string, string[]>): CrossModuleImport[] {
+  const imports: CrossModuleImport[] = [];
 
-  const relativePath = relative(fromDir, toDir);
-  if (relativePath === '') {
-    return `./${toFile}`;
-  }
-  if (!relativePath.startsWith('.')) {
-    return `./${relativePath}/${toFile}`;
+  for (const [modulePath, typeNames] of dependencyMap) {
+    const relativePath = resolveRelativeImport(fromSourceFile, modulePath);
+    imports.push({ fromPath: relativePath, typeNames });
   }
 
-  return join(relativePath, toFile);
+  return sortImportsBySource(imports);
 }
 
 function collectUsedMessageKeysForModule(module: Module, model: Model): Set<string> {

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

@@ -2,7 +2,7 @@ import ts from 'typescript';
 import type { Model, Module } from '../../../index';
 import { deriveModules } from '../../narrative-to-model/derive-modules';
 import { analyzeCodeUsage } from '../analysis/usage';
-import { computeCrossModuleImports } from '../cross-module-imports';
+import { computeAllCrossModuleDependencies } from '../cross-module-imports';
 import { sortFilesByPath } from '../ordering';
 import type { CrossModuleImport, GeneratedFile } from '../types';
 import { extractTypeIntegrationNames } from '../utils/integration-extractor';
@@ -22,11 +22,15 @@ export function generateAllModulesCode(model: Model, opts: GenerateModuleCodeOpt
   const modules =
     model.modules && model.modules.length > 0 ? model.modules : deriveModules(model.narratives, model.messages);
 
+  // Compute all cross-module dependencies in a single pass
+  const { importsPerModule, exportsPerModule } = computeAllCrossModuleDependencies(modules, model);
+
   const files: GeneratedFile[] = [];
 
   for (const module of modules) {
-    const crossModuleImports = computeCrossModuleImports(module, modules, model);
-    const code = generateModuleCode(module, model, opts, crossModuleImports);
+    const crossModuleImports = importsPerModule.get(module.sourceFile) ?? [];
+    const exportedTypes = exportsPerModule.get(module.sourceFile);
+    const code = generateModuleCode(module, model, opts, crossModuleImports, exportedTypes);
     files.push({
       path: module.sourceFile,
       code,
@@ -53,6 +57,7 @@ function generateModuleCode(
   model: Model,
   opts: GenerateModuleCodeOptions,
   crossModuleImports: CrossModuleImport[],
+  exportedTypes?: Set<string>,
 ): string {
   const f = ts.factory;
 
@@ -130,6 +135,7 @@ function generateModuleCode(
     usedFlowFunctionNames,
     narratives,
     crossModuleImports,
+    exportedTypes,
   );
 
   const file = f.createSourceFile(statements, f.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
@@ -146,6 +152,7 @@ function buildStatements(
   usedFlowFunctionNames: string[],
   flows: Model['narratives'],
   crossModuleImports: CrossModuleImport[],
+  exportedTypes?: Set<string>,
 ): ts.Statement[] {
   const f = tsModule.factory;
   const statements: ts.Statement[] = [];
@@ -185,7 +192,7 @@ function buildStatements(
       required: field.required,
     })),
   }));
-  statements.push(...buildTypeAliases(tsModule, adaptedMessages));
+  statements.push(...buildTypeAliases(tsModule, adaptedMessages, exportedTypes));
 
   for (const flow of flows) {
     statements.push(...buildFlowStatements(tsModule, flow, messages));

package/src/transformers/model-to-narrative/generators/types.ts

@@ -7,7 +7,7 @@ type Message = {
   fields: { name: string; type: string; required: boolean }[];
 };
 
-export function buildTypeAliases(ts: typeof tsNS, messages: Message[]): tsNS.Statement[] {
+export function buildTypeAliases(ts: typeof tsNS, messages: Message[], exportedTypes?: Set<string>): tsNS.Statement[] {
   const f = ts.factory;
 
   const mkK = (s: string) => f.createLiteralTypeNode(f.createStringLiteral(s, true));
@@ -37,11 +37,9 @@ export function buildTypeAliases(ts: typeof tsNS, messages: Message[]): tsNS.Sta
       m.type === 'event' ? 'Event' : m.type === 'command' ? 'Command' : m.type === 'query' ? 'Query' : 'State';
     const rhs = f.createTypeReferenceNode(baseTypeName, typeArgs);
 
-    return f.createTypeAliasDeclaration(
-      undefined, // No export keyword
-      name,
-      [],
-      rhs,
-    );
+    // Add export modifier if this type is imported by other modules
+    const modifiers = exportedTypes?.has(m.name) ? [f.createModifier(ts.SyntaxKind.ExportKeyword)] : undefined;
+
+    return f.createTypeAliasDeclaration(modifiers, name, [], rhs);
   });
 }

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

@@ -152,12 +152,13 @@ describe('module functionality', () => {
 
       expect(result.files).toHaveLength(2);
 
-      // Find the orders file
       const ordersFile = result.files.find((f) => f.path.includes('orders'));
       expect(ordersFile).toBeDefined();
 
-      // Orders file should import OrderCreated from shared
       expect(ordersFile!.code).toContain("import type { OrderCreated } from '../shared/types.narrative';");
+      const sharedFile = result.files.find((f) => f.path.includes('types'));
+      expect(sharedFile).toBeDefined();
+      expect(sharedFile!.code).toContain('export type OrderCreated = Event<');
     });
   });