@specverse/engines 4.1.13 → 4.1.15

package/libs/instance-factories/services/templates/prisma/behavior-generator.ts

@@ -24,13 +24,28 @@ export interface BehaviorContext {
   serviceName: string;
   operationName: string;
   prismaModel?: string;
+  /** Parameter names from the action definition (e.g., ['pollId', 'optionId', 'voterName']) */
+  parameterNames?: string[];
 }
 
+/**
+ * A step can be a plain string or an object with extra metadata.
+ * String form: "Find Order by id"
+ * Object form: { step: "Apply discount", as: "discount", returns: { amount: "number" } }
+ */
+export type Step = string | {
+  step: string;
+  /** Name the result variable (default: stepNResult) */
+  as?: string;
+  /** Declare return type for AI functions so types flow through */
+  returns?: Record<string, string> | string;
+};
+
 export interface BehaviorMetadata {
   preconditions?: string[];
   postconditions?: string[];
   sideEffects?: string[];
-  steps?: string[];
+  steps?: Step[];
   transactional?: boolean;
 }
 
@@ -43,6 +58,18 @@ export interface OperationMetadata {
 export interface BehaviorResult {
   body: string;
   helperMethods: string[];
+  /** Steps that couldn't be matched by conventions — need AI generation */
+  unmatchedSteps: Array<{
+    step: string;
+    functionName: string;
+    operationName: string;
+    /** Names of variables passed as the typed input object */
+    inputs: string[];
+    /** Declared return type from spec ({field: type} or a single type string) */
+    returns?: Record<string, string> | string;
+    /** Named result variable (default: stepNResult) */
+    resultName?: string;
+  }>;
 }
 
 /**
@@ -71,15 +98,18 @@ export function generateBehaviorWithHelpers(
   const parts: string[] = [];
   const helperMethods: string[] = [];
 
+  // Track variables declared by preconditions so steps can reuse them
+  const preconditionDeclared = new Set<string>();
+
   // Precondition guards
   const preconditions = generatePreconditionChecks(
-    behavior.preconditions || [], context
+    behavior.preconditions || [], context, preconditionDeclared
   );
   if (preconditions) parts.push(preconditions);
 
   // Main logic (from steps or inferred from operation semantics)
-  const { code, helpers } = generateStepLogic(
-    behavior.steps || [], context
+  const { code, helpers, unmatchedSteps } = generateStepLogic(
+    behavior.steps || [], context, preconditionDeclared
   );
   parts.push(code);
   helperMethods.push(...helpers);
@@ -92,7 +122,7 @@ export function generateBehaviorWithHelpers(
 
   // Event publishing
   const events = generateEventPublishing(
-    behavior.sideEffects || [], context.operationName
+    behavior.sideEffects || [], context.operationName, context.parameterNames
   );
   if (events) parts.push(events);
 
@@ -103,39 +133,56 @@ export function generateBehaviorWithHelpers(
     body = generateTransactionWrapper(body, context);
   }
 
-  return { body, helperMethods };
+  return { body, helperMethods, unmatchedSteps };
 }
 
 /**
  * Generate precondition checks from natural-language strings.
+ * Tracks declared variables to avoid duplicates and reuses fetched entities.
  */
 export function generatePreconditionChecks(
   preconditions: string[],
-  context: BehaviorContext
+  context: BehaviorContext,
+  declared?: Set<string>
 ): string {
   if (preconditions.length === 0) return '';
 
-  const checks = preconditions.map(pc => matchPreconditionPattern(pc, context));
+  if (!declared) declared = new Set<string>();
+  const checks = preconditions.map(pc => matchPreconditionPattern(pc, context, declared));
   return `    // === PRECONDITIONS ===\n${checks.join('\n')}`;
 }
 
+/** Find the parameter name that refers to a model (e.g., 'pollId' for 'Poll') */
+function findIdParam(modelName: string, paramNames: string[]): string {
+  const modelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+  // Check for modelId (e.g., pollId)
+  const idParam = paramNames.find(p => p === `${modelVar}Id`);
+  if (idParam) return idParam;
+  // Check for just 'id'
+  if (paramNames.includes('id')) return 'id';
+  return `${modelVar}Id`;
+}
+
 function matchPreconditionPattern(
   precondition: string,
-  context: BehaviorContext
+  context: BehaviorContext,
+  declared: Set<string>
 ): string {
   const pc = precondition.toLowerCase();
-  const prismaModel = context.prismaModel || context.modelName;
+  const params = context.parameterNames || [];
 
   // Pattern: "{Model} exists"
   const existsMatch = precondition.match(/^(\w+)\s+exists/i);
   if (existsMatch) {
     const entity = existsMatch[1];
     const entityVar = entity.charAt(0).toLowerCase() + entity.slice(1);
-    return `    // Guard: ${precondition}
-    const ${entityVar} = await prisma.${entityVar}.findUnique({ where: { id: params.id } });
-    if (!${entityVar}) {
-      throw new Error('Precondition failed: ${precondition}');
-    }`;
+    const idParam = findIdParam(entity, params);
+    if (declared.has(entityVar)) {
+      // Already fetched — just check it
+      return `    // Guard: ${precondition} (already fetched)`;
+    }
+    declared.add(entityVar);
+    return `    const ${entityVar} = await prisma.${entityVar}.findUniqueOrThrow({ where: { id: ${idParam} } });`;
   }
 
   // Pattern: "{field} is not empty" / "{field} is required"
@@ -143,31 +190,22 @@ function matchPreconditionPattern(
     const fieldMatch = precondition.match(/^(\w+)\s+is/i);
     if (fieldMatch) {
       const field = fieldMatch[1];
-      return `    // Guard: ${precondition}
-    if (!params.${field}) {
-      throw new Error('Precondition failed: ${precondition}');
-    }`;
+      const paramRef = params.includes(field) ? field : `params.${field}`;
+      return `    if (!${paramRef}) throw new Error('${field} is required');`;
     }
   }
 
   // Pattern: "{field} is valid"
   if (pc.includes('is valid')) {
-    return `    // Guard: ${precondition}
-    const validation = this.validate(params, { operation: '${context.operationName}' });
-    if (!validation.valid) {
-      throw new Error('Precondition failed: ${precondition} — ' + validation.errors.join(', '));
-    }`;
+    return `    // TODO: Implement validation: ${precondition}`;
   }
 
   // Pattern: "{X} matches {Y}" / "{X} equals {Y}"
   const matchesMatch = precondition.match(/^(\w+)\s+(?:matches|equals)\s+(.+)/i);
   if (matchesMatch) {
-    const left = matchesMatch[1];
-    const right = matchesMatch[2];
-    return `    // Guard: ${precondition}
-    if (params.${left.charAt(0).toLowerCase() + left.slice(1)} !== params.${right.charAt(0).toLowerCase() + right.slice(1)}) {
-      throw new Error('Precondition failed: ${precondition}');
-    }`;
+    const left = matchesMatch[1].charAt(0).toLowerCase() + matchesMatch[1].slice(1);
+    const right = matchesMatch[2].charAt(0).toLowerCase() + matchesMatch[2].slice(1);
+    return `    if (${left} !== ${right}) throw new Error('${matchesMatch[1]} must match ${matchesMatch[2]}');`;
   }
 
   // Pattern: "{Model} is {state}"
@@ -176,30 +214,43 @@ function matchPreconditionPattern(
     const model = stateMatch[1];
     const state = stateMatch[2];
     const modelVar = model.charAt(0).toLowerCase() + model.slice(1);
-    return `    // Guard: ${precondition}
-    const ${modelVar}State = await prisma.${modelVar}.findUniqueOrThrow({ where: { id: params.id } });
-    if (${modelVar}State.status !== '${state}') {
-      throw new Error('Precondition failed: ${precondition} (current: ' + ${modelVar}State.status + ')');
-    }`;
+    const idParam = findIdParam(model, params);
+
+    // If already declared, reuse; otherwise fetch
+    if (!declared.has(modelVar)) {
+      declared.add(modelVar);
+      return `    const ${modelVar} = await prisma.${modelVar}.findUniqueOrThrow({ where: { id: ${idParam} } });
+    if (${modelVar}.status !== '${state}') throw new Error('${model} must be ${state}, got ' + ${modelVar}.status);`;
+    }
+    return `    if (${modelVar}.status !== '${state}') throw new Error('${model} must be ${state}, got ' + ${modelVar}.status);`;
   }
 
   // Unrecognized
-  return `    // Guard: ${precondition}
-    // TODO: Implement precondition check`;
+  return `    // TODO: Implement precondition: ${precondition}`;
 }
 
 /**
  * Generate step logic using convention-based pattern matching.
  */
 function generateStepLogic(
-  steps: string[],
-  context: BehaviorContext
-): { code: string; helpers: string[] } {
+  steps: Step[],
+  context: BehaviorContext,
+  preconditionDeclared?: Set<string>
+): { code: string; helpers: string[]; unmatchedSteps: BehaviorResult['unmatchedSteps'] } {
   const helpers: string[] = [];
+  const unmatchedSteps: BehaviorResult['unmatchedSteps'] = [];
+
+  // Shared declared variables across steps — carried through from preconditions
+  const declaredVars = preconditionDeclared || new Set<string>();
 
   if (steps && steps.length > 0) {
-    const stepCode = steps.map((step, i) => {
-      if (typeof step !== 'string') {
+    const stepCode = steps.map((stepInput, i) => {
+      // Normalize to { text, as, returns }
+      const stepText = typeof stepInput === 'string' ? stepInput : stepInput.step;
+      const resultName = typeof stepInput === 'object' ? stepInput.as : undefined;
+      const returns = typeof stepInput === 'object' ? stepInput.returns : undefined;
+
+      if (typeof stepText !== 'string') {
         return `    // Step ${i + 1}: Complex operation — see expanded definition`;
       }
 
@@ -209,18 +260,32 @@ function generateStepLogic(
         serviceName: context.serviceName,
         operationName: context.operationName,
         stepNum: i + 1,
+        parameterNames: context.parameterNames,
+        declaredVars,
+        resultName,  // Pass through the named result
       };
 
-      const result = matchStep(step, ctx);
+      const result = matchStep(stepText, ctx);
       if (result.helperMethod) {
         helpers.push(result.helperMethod);
       }
+      if (!result.matched && result.functionName) {
+        unmatchedSteps.push({
+          step: stepText,
+          functionName: result.functionName,
+          operationName: context.operationName,
+          inputs: result.inputs || [],
+          returns,
+          resultName: resultName || `step${i + 1}Result`,
+        });
+      }
       return result.call;
     });
 
     return {
       code: `    // === EXECUTE ===\n${stepCode.join('\n\n')}`,
       helpers,
+      unmatchedSteps,
     };
   }
 
@@ -228,6 +293,7 @@ function generateStepLogic(
   return {
     code: `    // === EXECUTE ===\n${inferLogicFromOperationName(context)}`,
     helpers,
+    unmatchedSteps,
   };
 }
 
@@ -280,12 +346,17 @@ ${checks.join('\n')}
  */
 export function generateEventPublishing(
   sideEffects: string[],
-  operationName: string
+  operationName: string,
+  parameterNames?: string[]
 ): string {
   if (!sideEffects || sideEffects.length === 0) return '';
 
+  const paramFields = parameterNames?.length
+    ? parameterNames.join(', ') + ', '
+    : '';
+
   const publishes = sideEffects.map(event =>
-    `    this.emit('${event}', { operation: '${operationName}', timestamp: new Date().toISOString() });`
+    `    await eventBus.publish('${event}', { ${paramFields}timestamp: new Date().toISOString() } as any);`
   );
 
   return `    // === EVENTS ===\n${publishes.join('\n')}`;

package/libs/instance-factories/services/templates/prisma/controller-generator.ts

@@ -7,6 +7,7 @@
 
 import type { TemplateContext } from '@specverse/types';
 import { buildTransitionMap, isAutoField } from '@specverse/types/spec-rules';
+import { generateBehaviorWithHelpers, type BehaviorContext, type BehaviorMetadata } from './behavior-generator.js';
 
 /**
  * Generate Prisma controller for a model
@@ -25,9 +26,15 @@ export default function generatePrismaController(context: TemplateContext): stri
   const controllerName = controller.name;
   const modelName = model.name;
   const rawModelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
-  // Avoid JavaScript reserved words as variable names
+  // Avoid JavaScript reserved words as local variable names
   const RESERVED_WORDS = new Set(['import', 'export', 'default', 'class', 'function', 'return', 'delete', 'new', 'this', 'switch', 'case', 'break', 'continue', 'for', 'while', 'do', 'if', 'else', 'try', 'catch', 'finally', 'throw', 'typeof', 'instanceof', 'in', 'of', 'let', 'const', 'var', 'void', 'with', 'yield', 'async', 'await', 'enum', 'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'super', 'extends']);
   const modelVar = RESERVED_WORDS.has(rawModelVar) ? `${rawModelVar}Item` : rawModelVar;
+  // Prisma delegate name always matches the Prisma model's camelCase form —
+  // even when the model name is a JS reserved word (prisma.import, prisma.export).
+  // Access these via bracket notation so tsc doesn't choke on the keyword.
+  const prismaDelegate = RESERVED_WORDS.has(rawModelVar)
+    ? `prisma['${rawModelVar}']`
+    : `prisma.${rawModelVar}`;
   const curedOps = controller.cured || {};
 
   // Determine ID type for proper parsing
@@ -36,6 +43,9 @@ export default function generatePrismaController(context: TemplateContext): stri
   const idType = idAttr?.type || 'UUID';
   const needsIntParse = idType === 'Integer' || idType === 'Int' || idType === 'Number';
 
+  // Generate custom actions and collect AI behavior stubs
+  const customActions = generateCustomActions(controller, modelName, modelVar);
+
   return `/**
  * ${controllerName}
  * Model-specific business logic for ${modelName}
@@ -43,7 +53,8 @@ export default function generatePrismaController(context: TemplateContext): stri
  */
 
 import { PrismaClient } from '@prisma/client';
-${hasEventPublishing(curedOps, controller) ? `import { eventBus, EventName } from '../events/eventBus.js';` : ''}
+${hasEventPublishing(curedOps, controller) ? `import { eventBus } from '../events/eventBus.js';` : ''}
+${customActions.needsAiBehaviors ? `import * as aiBehaviors from '../behaviors/${modelName}Controller.ai.js';` : ''}
 
 const prisma = new PrismaClient();
 
@@ -57,18 +68,19 @@ function parseId(id: string): ${needsIntParse ? 'number' : 'string'} {
  */
 export class ${controllerName} {
   ${generateValidateMethod(model, modelName)}
-  ${curedOps.create ? generateCreateMethod(model, modelName, modelVar, controller, allModels) : ''}
-  ${curedOps.retrieve ? generateRetrieveMethod(model, modelName, modelVar) : ''}
-  ${curedOps.update ? generateUpdateMethod(model, modelName, modelVar, controller, allModels) : ''}
-  ${curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar, controller) : ''}
-  ${curedOps.delete ? generateDeleteMethod(model, modelName, modelVar, controller) : ''}
-  ${generateCustomActions(controller, modelName, modelVar)}
+  ${curedOps.create ? generateCreateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : ''}
+  ${curedOps.retrieve ? generateRetrieveMethod(model, modelName, modelVar, prismaDelegate) : ''}
+  ${curedOps.update ? generateUpdateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : ''}
+  ${curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar, prismaDelegate, controller) : ''}
+  ${curedOps.delete ? generateDeleteMethod(model, modelName, modelVar, prismaDelegate, controller) : ''}
+  ${customActions.code}
 }
 
 // Export singleton instance
 export const ${modelVar}Controller = new ${controllerName}();
 export default ${modelVar}Controller;
 `;
+
 }
 
 /**
@@ -157,10 +169,7 @@ function generateValidationLogic(model: any, dataParam: string = '_data', contex
 /**
  * Generate create method
  */
-function generateCreateMethod(model: any, modelName: string, modelVar: string, controller: any, allModels?: any[]): string {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const createEvent = hasEvents ? controller.publishes.find((e: string) => e.includes('Created')) : null;
-
+function generateCreateMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any, allModels?: any[]): string {
   return `
   /**
    * Create a new ${modelName}
@@ -177,17 +186,12 @@ function generateCreateMethod(model: any, modelName: string, modelVar: string, c
     ${generateFKTransform(model, 'prismaData', allModels)}
 
     // Create record
-    const ${modelVar} = await prisma.${modelVar}.create({
+    const ${modelVar} = await ${prismaDelegate}.create({
       data: prismaData${generateIncludeRelationships(model)}
     });
 
-    ${createEvent ? `
-    // Publish event
-    eventBus.publish(EventName.${createEvent}, {
-      ${modelVar},
-      timestamp: new Date().toISOString()
-    });
-    ` : ''}
+    // Publish CURED event
+    await eventBus.publish('${modelName}Created', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
 
     return ${modelVar};
   }
@@ -197,13 +201,13 @@ function generateCreateMethod(model: any, modelName: string, modelVar: string, c
 /**
  * Generate retrieve method
  */
-function generateRetrieveMethod(model: any, modelName: string, modelVar: string): string {
+function generateRetrieveMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string): string {
   return `
   /**
    * Retrieve ${modelName} by ID
    */
   public async retrieve(id: string): Promise<any> {
-    const ${modelVar} = await prisma.${modelVar}.findUnique({
+    const ${modelVar} = await ${prismaDelegate}.findUnique({
       where: { id: parseId(id) }${generateIncludeRelationships(model)}
     });
 
@@ -218,7 +222,7 @@ function generateRetrieveMethod(model: any, modelName: string, modelVar: string)
    * Retrieve all ${modelName}s
    */
   public async retrieveAll(options: { skip?: number; take?: number } = {}): Promise<any[]> {
-    return await prisma.${modelVar}.findMany({
+    return await ${prismaDelegate}.findMany({
       skip: options.skip,
       take: options.take${generateIncludeRelationships(model)}
     });
@@ -229,10 +233,7 @@ function generateRetrieveMethod(model: any, modelName: string, modelVar: string)
 /**
  * Generate update method
  */
-function generateUpdateMethod(model: any, modelName: string, modelVar: string, controller: any, allModels?: any[]): string {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const updateEvent = hasEvents ? controller.publishes.find((e: string) => e.includes('Updated')) : null;
-
+function generateUpdateMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any, allModels?: any[]): string {
   return `
   /**
    * Update ${modelName}
@@ -257,18 +258,13 @@ function generateUpdateMethod(model: any, modelName: string, modelVar: string, c
     ${generateFKTransform(model, 'updateData', allModels)}
 
     // Update record
-    const ${modelVar} = await prisma.${modelVar}.update({
+    const ${modelVar} = await ${prismaDelegate}.update({
       where: { id: parseId(id) },
       data: updateData${generateIncludeRelationships(model)}
     });
 
-    ${updateEvent ? `
-    // Publish event
-    eventBus.publish(EventName.${updateEvent}, {
-      ${modelVar},
-      timestamp: new Date().toISOString()
-    });
-    ` : ''}
+    // Publish CURED event
+    await eventBus.publish('${modelName}Updated', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
 
     return ${modelVar};
   }
@@ -278,7 +274,7 @@ function generateUpdateMethod(model: any, modelName: string, modelVar: string, c
 /**
  * Generate evolve method (lifecycle-aware updates)
  */
-function generateEvolveMethod(model: any, modelName: string, modelVar: string, controller: any): string {
+function generateEvolveMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any): string {
   // Extract lifecycle — handle both array and object format
   const lifecycles = Array.isArray(model.lifecycles) ? model.lifecycles :
     (model.lifecycles ? Object.entries(model.lifecycles).map(([name, lc]: [string, any]) => ({ name, ...lc })) : []);
@@ -302,7 +298,7 @@ function generateEvolveMethod(model: any, modelName: string, modelVar: string, c
     }
 
     // Get current record to check lifecycle state
-    const current = await prisma.${modelVar}.findUnique({ where: { id: parseId(id) } });
+    const current = await ${prismaDelegate}.findUnique({ where: { id: parseId(id) } });
     if (!current) {
       throw new Error('${modelName} not found');
     }
@@ -321,11 +317,14 @@ function generateEvolveMethod(model: any, modelName: string, modelVar: string, c
     ` : ''}
 
     // Update record
-    const ${modelVar} = await prisma.${modelVar}.update({
+    const ${modelVar} = await ${prismaDelegate}.update({
       where: { id: parseId(id) },
       data${generateIncludeRelationships(model)}
     });
 
+    // Publish CURED event
+    await eventBus.publish('${modelName}Evolved', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
+
     return ${modelVar};
   }
 `;
@@ -334,33 +333,23 @@ function generateEvolveMethod(model: any, modelName: string, modelVar: string, c
 /**
  * Generate delete method
  */
-function generateDeleteMethod(model: any, modelName: string, modelVar: string, controller: any): string {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const deleteEvent = hasEvents ? controller.publishes.find((e: string) => e.includes('Deleted')) : null;
-
+function generateDeleteMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any): string {
   return `
   /**
    * Delete ${modelName}
    */
   public async delete(id: string): Promise<void> {
-    ${deleteEvent ? `
     // Get record before deletion for event
-    const ${modelVar} = await prisma.${modelVar}.findUnique({ where: { id: parseId(id) } });
-    ` : ''}
+    const ${modelVar} = await ${prismaDelegate}.findUnique({ where: { id: parseId(id) } });
 
-    await prisma.${modelVar}.delete({
+    await ${prismaDelegate}.delete({
       where: { id: parseId(id) }
     });
 
-    ${deleteEvent ? `
-    // Publish event
+    // Publish CURED event
     if (${modelVar}) {
-      eventBus.publish(EventName.${deleteEvent}, {
-        ${modelVar},
-        timestamp: new Date().toISOString()
-      });
+      await eventBus.publish('${modelName}Deleted', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
     }
-    ` : ''}
   }
 `;
 }
@@ -368,26 +357,59 @@ function generateDeleteMethod(model: any, modelName: string, modelVar: string, c
 /**
  * Generate custom actions defined in controller
  */
-function generateCustomActions(controller: any, modelName: string, modelVar: string): string {
+interface CustomActionsResult {
+  code: string;
+  unmatchedSteps: Array<{ step: string; functionName: string; operationName: string }>;
+  needsAiBehaviors: boolean;
+}
+
+function generateCustomActions(controller: any, modelName: string, modelVar: string): CustomActionsResult {
   if (!controller.actions || Object.keys(controller.actions).length === 0) {
-    return '';
+    return { code: '', unmatchedSteps: [], needsAiBehaviors: false };
   }
 
   const actions: string[] = [];
+  const allUnmatchedSteps: Array<{ step: string; functionName: string; operationName: string }> = [];
 
   Object.entries(controller.actions).forEach(([actionName, action]: [string, any]) => {
+    const behavior: BehaviorMetadata = {
+      preconditions: action.requires || action.preconditions || [],
+      steps: action.steps || [],
+      postconditions: action.ensures || action.postconditions || [],
+      sideEffects: action.publishes || action.events || [],
+      transactional: action.transactional,
+    };
+
+    const ctx: BehaviorContext = {
+      modelName,
+      serviceName: `${modelName}Controller`,
+      operationName: actionName,
+      prismaModel: modelVar,
+      parameterNames: Object.keys(action.parameters || {}),
+    };
+
+    const result = generateBehaviorWithHelpers(behavior, {}, ctx);
+    allUnmatchedSteps.push(...result.unmatchedSteps);
+
     actions.push(`
   /**
    * ${actionName}
    * ${action.description || ''}
    */
   public async ${actionName}(${generateActionParams(action)}): Promise<any> {
-    // TODO: Implement ${actionName} logic
-    throw new Error('${actionName} not implemented');
+${result.body}
   }`);
+
+    if (result.helperMethods.length > 0) {
+      actions.push(...result.helperMethods);
+    }
   });
 
-  return actions.join('\n');
+  return {
+    code: actions.join('\n'),
+    unmatchedSteps: allUnmatchedSteps,
+    needsAiBehaviors: allUnmatchedSteps.length > 0,
+  };
 }
 
 /**
@@ -509,5 +531,7 @@ ${includes}
  * Check if controller publishes events
  */
 function hasEventPublishing(curedOps: any, controller: any): boolean {
-  return controller.publishes && Array.isArray(controller.publishes) && controller.publishes.length > 0;
+  // Controllers always publish CURED events (Created, Updated, Deleted, Evolved)
+  // so the event bus is always needed
+  return true;
 }