@auto-engineer/server-generator-apollo-emmett 0.13.0 → 0.13.2

package/package.json

@@ -31,8 +31,8 @@
     "graphql-type-json": "^0.3.2",
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
-    "@auto-engineer/message-bus": "0.13.0",
-    "@auto-engineer/narrative": "0.13.0"
+    "@auto-engineer/message-bus": "0.13.2",
+    "@auto-engineer/narrative": "0.13.2"
   },
   "publishConfig": {
     "access": "public"
@@ -43,9 +43,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "0.13.0"
+    "@auto-engineer/cli": "0.13.2"
   },
-  "version": "0.13.0",
+  "version": "0.13.2",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/extract/commands.ts

@@ -1,5 +1,4 @@
-import { CommandExample, EventExample } from '@auto-engineer/narrative';
-import { Message, MessageDefinition } from '../types';
+import type { Message, MessageDefinition, EventRef, CommandRef, ErrorRef } from '../types';
 import { extractFieldsFromMessage } from './fields';
 
 function createCommandMessage(
@@ -22,9 +21,9 @@ function createCommandMessage(
 
 export function extractCommandsFromGwt(
   gwtSpecs: Array<{
-    given?: Array<EventExample | unknown>;
-    when?: CommandExample | EventExample | unknown[];
-    then: Array<EventExample | unknown | { errorType: string; message?: string }>;
+    given?: Array<EventRef | unknown>;
+    when?: CommandRef | EventRef | unknown[];
+    then: Array<EventRef | unknown | ErrorRef>;
   }>,
   allMessages: MessageDefinition[],
 ): { commands: Message[]; commandSchemasByName: Record<string, Message> } {
@@ -85,9 +84,9 @@ function processCommandExample(
 
 export function extractCommandsFromThen(
   gwtSpecs: Array<{
-    given?: Array<EventExample | unknown>;
-    when?: CommandExample | EventExample | unknown[];
-    then: Array<EventExample | unknown | { errorType: string; message?: string }>;
+    given?: Array<EventRef | unknown>;
+    when?: CommandRef | EventRef | unknown[];
+    then: Array<EventRef | unknown | ErrorRef>;
   }>,
   allMessages: MessageDefinition[],
 ): { commands: Message[]; commandSchemasByName: Record<string, Message> } {

package/src/codegen/extract/data-sink.ts

@@ -1,37 +1,26 @@
-import { CommandExample, Slice, type Example } from '@auto-engineer/narrative';
+import type { Slice } from '@auto-engineer/narrative';
+import type { CommandRef, ErrorRef } from '../types';
+import { extractGwtSpecsFromSlice, type GwtResult } from './step-converter';
 
 function resolveStreamId(stream: string, exampleData: Record<string, unknown>): string {
   return stream.replace(/\$\{([^}]+)\}/g, (_, key: string) => String(exampleData?.[key] ?? 'unknown'));
 }
 
-function extractExampleDataFromReact(firstSpec: { when: unknown }): Record<string, unknown> {
+function extractExampleDataFromEventWhen(firstSpec: GwtResult): Record<string, unknown> {
   if (Array.isArray(firstSpec.when)) {
-    const firstWhen = firstSpec.when[0] as { exampleData?: Record<string, unknown> } | undefined;
-    return typeof firstWhen?.exampleData === 'object' && firstWhen.exampleData !== null ? firstWhen.exampleData : {};
+    const firstWhen = firstSpec.when[0];
+    return firstWhen?.exampleData ?? {};
   }
   return {};
 }
 
-function extractExampleDataFromCommand(firstSpec: { then: unknown }): Record<string, unknown> {
-  const then = firstSpec.then as (CommandExample | { errorType: string })[];
-  const firstExample = then.find((t): t is CommandExample => 'exampleData' in t);
-  return typeof firstExample?.exampleData === 'object' && firstExample.exampleData !== null
-    ? firstExample.exampleData
-    : {};
+function extractExampleDataFromCommand(firstSpec: GwtResult): Record<string, unknown> {
+  const then = firstSpec.then as (CommandRef | ErrorRef)[];
+  const firstExample = then.find((t): t is CommandRef => 'exampleData' in t);
+  return firstExample?.exampleData ?? {};
 }
 
-function extractExampleDataFromQuery(firstSpec: { when: unknown }): Record<string, unknown> {
-  if (Array.isArray(firstSpec.when)) {
-    const firstWhen = firstSpec.when[0] as { exampleData?: Record<string, unknown> } | undefined;
-    return typeof firstWhen?.exampleData === 'object' && firstWhen.exampleData !== null ? firstWhen.exampleData : {};
-  }
-  return {};
-}
-
-function extractExampleDataFromSpecs(
-  slice: Slice,
-  gwtSpecs: Array<{ given?: unknown; when: unknown; then: unknown }>,
-): Record<string, unknown> {
+function extractExampleDataFromSpecs(slice: Slice, gwtSpecs: GwtResult[]): Record<string, unknown> {
   if (gwtSpecs.length === 0) {
     return {};
   }
@@ -39,31 +28,15 @@ function extractExampleDataFromSpecs(
   const firstSpec = gwtSpecs[0];
   switch (slice.type) {
     case 'react':
-      return extractExampleDataFromReact(firstSpec);
+    case 'query':
+      return extractExampleDataFromEventWhen(firstSpec);
     case 'command':
       return extractExampleDataFromCommand(firstSpec);
-    case 'query':
-      return extractExampleDataFromQuery(firstSpec);
     default:
       return {};
   }
 }
 
-function extractGwtSpecs(slice: Slice) {
-  if (!('server' in slice)) return [];
-  const specs = slice.server?.specs;
-  const rules = specs?.rules;
-  return Array.isArray(rules) && rules.length > 0
-    ? rules.flatMap((rule) =>
-        rule.examples.map((example: Example) => ({
-          given: example.given,
-          when: example.when,
-          then: example.then,
-        })),
-      )
-    : [];
-}
-
 function isValidStreamSink(item: unknown): item is { destination: { pattern: string } } {
   return (
     typeof item === 'object' &&
@@ -91,11 +64,11 @@ function processStreamSink(item: unknown, exampleData: Record<string, unknown>)
 
 export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
   if (!('server' in slice)) return {};
-  const gwtSpecs = extractGwtSpecs(slice);
-  const exampleData = extractExampleDataFromSpecs(slice, gwtSpecs);
-  if (!('server' in slice) || slice.server == null || !('data' in slice.server) || !Array.isArray(slice.server.data)) {
+  if (slice.server == null || !('data' in slice.server) || !Array.isArray(slice.server.data)) {
     return {};
   }
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const exampleData = extractExampleDataFromSpecs(slice, gwtSpecs);
   const serverData = slice.server.data;
 
   for (const item of serverData) {

package/src/codegen/extract/events.ts

@@ -1,7 +1,6 @@
-import { EventExample } from '@auto-engineer/narrative';
-import { Message, MessageDefinition } from '../types';
+import type { Message, MessageDefinition, EventRef, ErrorRef } from '../types';
 import { extractFieldsFromMessage } from './fields';
-import { ReactGwtSpec } from './messages';
+import type { ReactGwtSpec } from './messages';
 
 function createEventMessage(
   eventRef: string | undefined,
@@ -27,7 +26,7 @@ function createEventMessage(
 }
 
 export function extractEventsFromThen(
-  thenItems: Array<EventExample | { errorType: string; message?: string }>,
+  thenItems: Array<EventRef | ErrorRef>,
   allMessages: MessageDefinition[],
   currentSliceName?: string,
   currentFlowName?: string,
@@ -41,7 +40,7 @@ export function extractEventsFromThen(
 }
 
 export function extractEventsFromGiven(
-  givenEvents: EventExample[] | undefined,
+  givenEvents: EventRef[] | undefined,
   allMessages: MessageDefinition[],
   currentSliceName?: string,
   currentFlowName?: string,

package/src/codegen/extract/gwt.ts

@@ -1,52 +1,35 @@
-import { Slice, CommandExample, EventExample, StateExample, Example } from '@auto-engineer/narrative';
-import { GwtCondition } from '../types';
+import type { Slice } from '@auto-engineer/narrative';
+import type { GwtCondition, CommandRef, EventRef } from '../types';
+import { extractGwtSpecsFromSlice, type GwtConditionWithRule } from './step-converter';
 
 export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
   if (slice.type !== 'command') {
     return {};
   }
 
-  const gwtSpecs = extractGwtSpecs(slice);
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
   const mapping = buildCommandMapping(gwtSpecs);
   return enhanceMapping(mapping);
 }
 
-function extractGwtSpecs(slice: Slice) {
-  if (!('server' in slice)) return [];
-  const specs = slice.server?.specs;
-  const rules = specs?.rules;
-  return Array.isArray(rules) && rules.length > 0
-    ? rules.flatMap((rule) =>
-        rule.examples.map((example: Example) => ({
-          given: example.given,
-          when: example.when,
-          then: example.then,
-          description: example.description,
-          ruleDescription: rule.description,
-        })),
-      )
-    : [];
+function isCommandRef(when: CommandRef | EventRef[]): when is CommandRef {
+  return !Array.isArray(when) && 'commandRef' in when;
 }
 
-function buildCommandMapping(
-  gwtSpecs: Array<{ given: unknown; when: unknown; then: unknown; description?: string; ruleDescription?: string }>,
-) {
+function buildCommandMapping(gwtSpecs: GwtConditionWithRule[]) {
   const mapping: Record<string, GwtCondition[]> = {};
 
   for (const gwt of gwtSpecs) {
-    let command: string | undefined;
-    if (Array.isArray(gwt.when)) {
+    if (!isCommandRef(gwt.when)) {
       continue;
-    } else {
-      const whenCmd = gwt.when as { commandRef?: string } | undefined;
-      command = whenCmd?.commandRef;
     }
+    const command = gwt.when.commandRef;
     if (typeof command === 'string' && command.length > 0) {
       mapping[command] = mapping[command] ?? [];
       mapping[command].push({
-        given: gwt.given as Array<EventExample | StateExample> | undefined,
-        when: gwt.when as CommandExample | EventExample[],
-        then: gwt.then as Array<EventExample | StateExample | CommandExample | { errorType: string; message?: string }>,
+        given: gwt.given,
+        when: gwt.when,
+        then: gwt.then,
         description: gwt.description,
         ruleDescription: gwt.ruleDescription,
       });

package/src/codegen/extract/messages.ts

@@ -1,10 +1,11 @@
 import { extractCommandsFromGwt, extractCommandsFromThen } from './commands';
-import { CommandExample, EventExample, Slice } from '@auto-engineer/narrative';
-import { Message, MessageDefinition } from '../types';
+import type { Slice } from '@auto-engineer/narrative';
+import type { Message, MessageDefinition, EventRef, CommandRef } from '../types';
 import { extractEventsFromGiven, extractEventsFromThen, extractEventsFromWhen } from './events';
 import { extractFieldsFromMessage } from './fields';
 import { extractProjectionIdField, extractProjectionSingleton } from './projection';
 import { extractStatesFromData, extractStatesFromTarget } from './states';
+import { extractGwtFromSpecs } from './step-converter';
 import createDebug from 'debug';
 
 const debug = createDebug('auto:server-generator-apollo-emmett:extract:messages');
@@ -23,8 +24,8 @@ export interface ExtractedMessages {
 }
 
 export interface ReactGwtSpec {
-  when?: EventExample[];
-  then: CommandExample[];
+  when?: EventRef[];
+  then: CommandRef[];
 }
 
 const EMPTY_EXTRACTED_MESSAGES: ExtractedMessages = {
@@ -59,17 +60,12 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
   }
 
   const specs = slice.server?.specs;
-  const rules = specs?.rules;
-  const gwtSpecs =
-    Array.isArray(rules) && rules.length > 0
-      ? rules.flatMap((rule) =>
-          rule.examples.map((example) => ({
-            given: example.given,
-            when: example.when,
-            then: example.then,
-          })),
-        )
-      : [];
+  if (!Array.isArray(specs) || specs.length === 0) {
+    debugCommand('  No specs found, returning empty');
+    return EMPTY_EXTRACTED_MESSAGES;
+  }
+
+  const gwtSpecs = extractGwtFromSpecs(specs, 'command');
   debugCommand('  Found %d GWT specs', gwtSpecs.length);
 
   const { commands, commandSchemasByName } = extractCommandsFromGwt(gwtSpecs, allMessages);
@@ -77,10 +73,9 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
   debugCommand('  Command schemas: %o', Object.keys(commandSchemasByName));
 
   const events: Message[] = gwtSpecs.flatMap((gwt): Message[] => {
-    const givenEventsOnly = gwt.given?.filter((item): item is EventExample => 'eventRef' in item);
-    const givenEvents = extractEventsFromGiven(givenEventsOnly, allMessages, slice.name);
+    const givenEvents = extractEventsFromGiven(gwt.given, allMessages, slice.name);
 
-    const thenEventsOnly = gwt.then.filter((item): item is EventExample => 'eventRef' in item);
+    const thenEventsOnly = gwt.then.filter((item): item is EventRef => 'eventRef' in item);
     const thenEvents = extractEventsFromThen(thenEventsOnly, allMessages, slice.name);
     debugCommand('    GWT: given=%d events, then=%d events', givenEvents.length, thenEvents.length);
     return [...givenEvents, ...thenEvents];
@@ -107,17 +102,9 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
   }
 
   const specs = slice.server?.specs;
-  const rules = specs?.rules;
-  const gwtSpecs =
-    Array.isArray(rules) && rules.length > 0
-      ? rules.flatMap((rule) =>
-          rule.examples.map((example) => ({
-            given: example.given,
-            when: example.when,
-            then: example.then,
-          })),
-        )
-      : [];
+  const hasSpecs = Array.isArray(specs) && specs.length > 0;
+
+  const gwtSpecs = hasSpecs ? extractGwtFromSpecs(specs, 'query') : [];
   debugQuery('  Found %d GWT specs', gwtSpecs.length);
 
   const projectionIdField = extractProjectionIdField(slice);
@@ -127,35 +114,21 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
   debugQuery('  Projection singleton: %s', projectionSingleton);
 
   const events: Message[] = gwtSpecs.flatMap((gwt) => {
-    const eventsFromGiven = Array.isArray(gwt.given)
-      ? gwt.given.filter((item): item is EventExample => 'eventRef' in item)
-      : [];
-    let eventsFromWhen: EventExample[] = [];
-    if (Array.isArray(gwt.when)) {
-      eventsFromWhen = gwt.when.filter((item): item is EventExample => 'eventRef' in item);
-    } else if (gwt.when != null && typeof gwt.when === 'object' && 'eventRef' in gwt.when) {
-      // when is a single object, convert to array
-      const whenItem = gwt.when as EventExample;
-      if (whenItem.eventRef && whenItem.eventRef.trim() !== '') {
-        eventsFromWhen = [whenItem];
-      }
-    }
-    const givenEvents = extractEventsFromGiven(eventsFromGiven, allMessages);
-    const whenEvents = eventsFromWhen
-      .map((eventExample) => {
-        const fields = extractFieldsFromMessage(eventExample.eventRef, 'event', allMessages);
-        const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventExample.eventRef);
-        const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
-
-        return {
-          type: eventExample.eventRef,
-          fields,
-          source: 'when' as const, // Mark as 'when' source for query events
-          sourceFlowName: metadata?.sourceFlowName,
-          sourceSliceName: metadata?.sourceSliceName,
-        } as Message;
-      })
-      .filter((event): event is Message => event.type !== undefined);
+    const eventsFromWhen: EventRef[] = Array.isArray(gwt.when) ? gwt.when : [];
+    const givenEvents = extractEventsFromGiven(gwt.given, allMessages);
+    const whenEvents: Message[] = eventsFromWhen.map((eventExample) => {
+      const fields = extractFieldsFromMessage(eventExample.eventRef, 'event', allMessages);
+      const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventExample.eventRef);
+      const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
+
+      return {
+        type: eventExample.eventRef,
+        fields,
+        source: 'when',
+        sourceFlowName: metadata?.sourceFlowName,
+        sourceSliceName: metadata?.sourceSliceName,
+      };
+    });
 
     return [...givenEvents, ...whenEvents];
   });
@@ -186,20 +159,20 @@ function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[])
   }
 
   const specs = slice.server?.specs;
-  const rules = specs?.rules;
-  const gwtSpecs =
-    Array.isArray(rules) && rules.length > 0
-      ? rules.flatMap((rule) =>
-          rule.examples.map((example) => ({
-            given: example.given,
-            when: example.when,
-            then: example.then,
-          })),
-        )
-      : [];
+  if (!Array.isArray(specs) || specs.length === 0) {
+    debugReact('  No specs found, returning empty');
+    return EMPTY_EXTRACTED_MESSAGES;
+  }
+
+  const gwtSpecs = extractGwtFromSpecs(specs, 'react');
   debugReact('  Found %d GWT specs', gwtSpecs.length);
 
-  const events = extractEventsFromWhen(gwtSpecs as ReactGwtSpec[], allMessages);
+  const reactGwtSpecs: ReactGwtSpec[] = gwtSpecs.map((gwt) => ({
+    when: Array.isArray(gwt.when) ? gwt.when : undefined,
+    then: gwt.then.filter((item): item is CommandRef => 'commandRef' in item),
+  }));
+
+  const events = extractEventsFromWhen(reactGwtSpecs, allMessages);
   debugReact('  Extracted %d events from when', events.length);
 
   const { commands, commandSchemasByName } = extractCommandsFromThen(gwtSpecs, allMessages);

package/src/codegen/extract/query.ts

@@ -1,29 +1,31 @@
-import { EventExample, Slice } from '@auto-engineer/narrative';
+import type { Slice } from '@auto-engineer/narrative';
+import type { EventRef, StateRef } from '../types';
+import { extractGwtFromSpecs } from './step-converter';
 
 interface QueryGwtCondition {
   description: string;
-  given?: EventExample[];
-  when: EventExample[];
-  then: Array<{ stateRef: string; exampleData: Record<string, unknown> }>;
+  given?: EventRef[];
+  when: EventRef[];
+  then: Array<StateRef>;
 }
 
 export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
   if (slice.type !== 'query') return [];
 
   const specs = slice.server?.specs;
-  const rules = specs?.rules;
+  if (!Array.isArray(specs) || specs.length === 0) return [];
 
-  const examples = Array.isArray(rules) && rules.length > 0 ? rules.flatMap((rule) => rule.examples) : [];
+  const gwtResults = extractGwtFromSpecs(specs, 'query');
 
-  return examples.map((ex) => {
-    const givenEvents = Array.isArray(ex.given) ? ex.given.filter((i): i is EventExample => 'eventRef' in i) : [];
-    const whenEvents = Array.isArray(ex.when) ? ex.when.filter((i): i is EventExample => 'eventRef' in i) : [];
+  return gwtResults.map((gwt) => {
+    const whenEvents: EventRef[] = Array.isArray(gwt.when) ? gwt.when : [];
+    const thenStates = gwt.then.filter((i): i is StateRef => 'stateRef' in i);
 
     return {
-      description: ex.description,
-      given: givenEvents.length > 0 ? givenEvents : undefined,
+      description: gwt.description,
+      given: gwt.given.length > 0 ? gwt.given : undefined,
       when: whenEvents,
-      then: ex.then.filter((i): i is { stateRef: string; exampleData: Record<string, unknown> } => 'stateRef' in i),
+      then: thenStates,
     };
   });
 }

package/src/codegen/extract/slice-normalizer.ts

@@ -0,0 +1,88 @@
+import type { Slice, Spec } from '@auto-engineer/narrative';
+import {
+  type CommandRef,
+  type EventRef,
+  type StateRef,
+  type ErrorRef,
+  type SliceType,
+  getSliceType,
+  extractGwtFromSpecs,
+  type GwtConditionWithRule,
+} from './step-converter';
+
+interface NormalizedExample {
+  description: string;
+  given: EventRef[];
+  when: CommandRef | EventRef[];
+  then: Array<EventRef | StateRef | CommandRef | ErrorRef>;
+}
+
+interface NormalizedRule {
+  description: string;
+  examples: NormalizedExample[];
+}
+
+interface NormalizedSpecs {
+  name: string;
+  rules: NormalizedRule[];
+}
+
+function gwtToNormalizedExample(gwt: GwtConditionWithRule): NormalizedExample {
+  return {
+    description: gwt.description,
+    given: gwt.given,
+    when: gwt.when,
+    then: gwt.then,
+  };
+}
+
+function groupGwtByRule(gwtResults: GwtConditionWithRule[]): Map<string, GwtConditionWithRule[]> {
+  const grouped = new Map<string, GwtConditionWithRule[]>();
+  for (const gwt of gwtResults) {
+    const existing = grouped.get(gwt.ruleDescription) ?? [];
+    existing.push(gwt);
+    grouped.set(gwt.ruleDescription, existing);
+  }
+  return grouped;
+}
+
+function normalizeSpecsForTemplate(specs: Spec[], sliceType: SliceType): NormalizedSpecs | null {
+  if (specs.length === 0) return null;
+
+  const gwtResults = extractGwtFromSpecs(specs, sliceType);
+  const groupedByRule = groupGwtByRule(gwtResults);
+
+  const featureName = specs[0]?.feature ?? '';
+
+  const rules: NormalizedRule[] = Array.from(groupedByRule.entries()).map(([ruleName, gwts]) => ({
+    description: ruleName,
+    examples: gwts.map(gwtToNormalizedExample),
+  }));
+
+  return {
+    name: featureName,
+    rules,
+  };
+}
+
+type SliceWithServer = Slice & { server?: { specs?: Spec[] } };
+type NormalizedSlice<T extends SliceWithServer> = Omit<T, 'server'> & {
+  server?: Omit<T['server'], 'specs'> & { specs?: NormalizedSpecs | null };
+};
+
+export function normalizeSliceForTemplate<T extends SliceWithServer>(slice: T): NormalizedSlice<T> {
+  if (!('server' in slice) || !slice.server?.specs) {
+    return slice as NormalizedSlice<T>;
+  }
+
+  const sliceType = getSliceType(slice);
+  const normalizedSpecs = normalizeSpecsForTemplate(slice.server.specs, sliceType);
+
+  return {
+    ...slice,
+    server: {
+      ...slice.server,
+      specs: normalizedSpecs,
+    },
+  } as NormalizedSlice<T>;
+}

package/src/codegen/extract/step-converter.ts

@@ -0,0 +1,124 @@
+import type { Example, Spec, Slice } from '@auto-engineer/narrative';
+import {
+  type SliceType,
+  type MajorKeyword,
+  type CommandRef,
+  type EventRef,
+  type StateRef,
+  type ErrorRef,
+  isStepWithDocString,
+  isStepWithError,
+  resolveMajorKeyword,
+  getSliceType,
+} from './step-types';
+
+export type { CommandRef, EventRef, StateRef, ErrorRef, SliceType };
+export { getSliceType };
+
+export interface GwtResult {
+  given: EventRef[];
+  when: CommandRef | EventRef[];
+  then: Array<EventRef | StateRef | CommandRef | ErrorRef>;
+  description: string;
+}
+
+interface ParsedSteps {
+  given: EventRef[];
+  whenItems: Array<{ text: string; exampleData: Record<string, unknown> }>;
+  thenItems: Array<{ text: string; exampleData: Record<string, unknown> }>;
+  thenErrors: ErrorRef[];
+}
+
+function parseSteps(example: Example): ParsedSteps {
+  const given: EventRef[] = [];
+  const whenItems: Array<{ text: string; exampleData: Record<string, unknown> }> = [];
+  const thenItems: Array<{ text: string; exampleData: Record<string, unknown> }> = [];
+  const thenErrors: ErrorRef[] = [];
+
+  let effectiveKeyword: MajorKeyword = 'Given';
+
+  for (const step of example.steps) {
+    if (isStepWithError(step)) {
+      thenErrors.push({ errorType: step.error.type, message: step.error.message });
+      continue;
+    }
+
+    if (!isStepWithDocString(step)) continue;
+
+    effectiveKeyword = resolveMajorKeyword(step.keyword, effectiveKeyword);
+    const exampleData = step.docString ?? {};
+
+    if (effectiveKeyword === 'Given') {
+      given.push({ eventRef: step.text, exampleData });
+    } else if (effectiveKeyword === 'When') {
+      whenItems.push({ text: step.text, exampleData });
+    } else if (effectiveKeyword === 'Then') {
+      thenItems.push({ text: step.text, exampleData });
+    }
+  }
+
+  return { given, whenItems, thenItems, thenErrors };
+}
+
+function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description: string): GwtResult {
+  const { given, whenItems, thenItems, thenErrors } = parsed;
+
+  if (sliceType === 'command') {
+    return {
+      given,
+      when: { commandRef: whenItems[0]?.text ?? '', exampleData: whenItems[0]?.exampleData ?? {} },
+      then: [...thenItems.map((t) => ({ eventRef: t.text, exampleData: t.exampleData })), ...thenErrors],
+      description,
+    };
+  }
+
+  if (sliceType === 'react') {
+    return {
+      given,
+      when: whenItems.map((w) => ({ eventRef: w.text, exampleData: w.exampleData })),
+      then: [...thenItems.map((t) => ({ commandRef: t.text, exampleData: t.exampleData })), ...thenErrors],
+      description,
+    };
+  }
+
+  return {
+    given,
+    when: whenItems.map((w) => ({ eventRef: w.text, exampleData: w.exampleData })),
+    then: [...thenItems.map((t) => ({ stateRef: t.text, exampleData: t.exampleData })), ...thenErrors],
+    description,
+  };
+}
+
+export function stepsToGwt(example: Example, sliceType: SliceType): GwtResult {
+  const parsed = parseSteps(example);
+  return buildGwtResult(sliceType, parsed, example.name);
+}
+
+export interface GwtConditionWithRule extends GwtResult {
+  ruleDescription: string;
+}
+
+export function extractGwtFromSpecs(specs: Spec[], sliceType: SliceType): GwtConditionWithRule[] {
+  const results: GwtConditionWithRule[] = [];
+
+  for (const spec of specs) {
+    for (const rule of spec.rules) {
+      for (const example of rule.examples) {
+        const gwt = stepsToGwt(example, sliceType);
+        results.push({
+          ...gwt,
+          ruleDescription: rule.name,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+export function extractGwtSpecsFromSlice(slice: Slice): GwtConditionWithRule[] {
+  if (!('server' in slice)) return [];
+  const specs = slice.server?.specs;
+  if (!Array.isArray(specs) || specs.length === 0) return [];
+  return extractGwtFromSpecs(specs, getSliceType(slice));
+}