@specverse/engines 4.1.13 → 4.1.15

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

@@ -1,4 +1,5 @@
 import { buildTransitionMap, isAutoField } from "@specverse/types/spec-rules";
+import { generateBehaviorWithHelpers } from "./behavior-generator.js";
 function generatePrismaController(context) {
   const { controller, model, spec, models: allModels } = context;
   if (!controller) {
@@ -12,10 +13,12 @@ function generatePrismaController(context) {
   const rawModelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
   const RESERVED_WORDS = /* @__PURE__ */ 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;
+  const prismaDelegate = RESERVED_WORDS.has(rawModelVar) ? `prisma['${rawModelVar}']` : `prisma.${rawModelVar}`;
   const curedOps = controller.cured || {};
   const idAttr = (Array.isArray(model.attributes) ? model.attributes : Object.values(model.attributes || {})).find((a) => a.name === "id");
   const idType = idAttr?.type || "UUID";
   const needsIntParse = idType === "Integer" || idType === "Int" || idType === "Number";
+  const customActions = generateCustomActions(controller, modelName, modelVar);
   return `/**
  * ${controllerName}
  * Model-specific business logic for ${modelName}
@@ -23,7 +26,8 @@ function generatePrismaController(context) {
  */
 
 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();
 
@@ -37,12 +41,12 @@ 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
@@ -113,9 +117,7 @@ function generateValidationLogic(model, dataParam = "_data", contextParam = "_co
   });
   return validations.join("\n") || "// No validation rules defined";
 }
-function generateCreateMethod(model, modelName, modelVar, controller, allModels) {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const createEvent = hasEvents ? controller.publishes.find((e) => e.includes("Created")) : null;
+function generateCreateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) {
   return `
   /**
    * Create a new ${modelName}
@@ -132,29 +134,24 @@ function generateCreateMethod(model, modelName, modelVar, controller, allModels)
     ${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};
   }
 `;
 }
-function generateRetrieveMethod(model, modelName, modelVar) {
+function generateRetrieveMethod(model, modelName, modelVar, prismaDelegate) {
   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)}
     });
 
@@ -169,16 +166,14 @@ function generateRetrieveMethod(model, modelName, modelVar) {
    * 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)}
     });
   }
 `;
 }
-function generateUpdateMethod(model, modelName, modelVar, controller, allModels) {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const updateEvent = hasEvents ? controller.publishes.find((e) => e.includes("Updated")) : null;
+function generateUpdateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) {
   return `
   /**
    * Update ${modelName}
@@ -203,24 +198,19 @@ function generateUpdateMethod(model, modelName, modelVar, controller, allModels)
     ${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};
   }
 `;
 }
-function generateEvolveMethod(model, modelName, modelVar, controller) {
+function generateEvolveMethod(model, modelName, modelVar, prismaDelegate, controller) {
   const lifecycles = Array.isArray(model.lifecycles) ? model.lifecycles : model.lifecycles ? Object.entries(model.lifecycles).map(([name, lc]) => ({ name, ...lc })) : [];
   const lifecycle = lifecycles[0];
   const lifecycleName = lifecycle?.name || "status";
@@ -239,7 +229,7 @@ function generateEvolveMethod(model, modelName, modelVar, controller) {
     }
 
     // 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');
     }
@@ -258,61 +248,78 @@ function generateEvolveMethod(model, modelName, modelVar, controller) {
     ` : ""}
 
     // 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};
   }
 `;
 }
-function generateDeleteMethod(model, modelName, modelVar, controller) {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const deleteEvent = hasEvents ? controller.publishes.find((e) => e.includes("Deleted")) : null;
+function generateDeleteMethod(model, modelName, modelVar, prismaDelegate, controller) {
   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);
     }
-    ` : ""}
   }
 `;
 }
 function generateCustomActions(controller, modelName, modelVar) {
   if (!controller.actions || Object.keys(controller.actions).length === 0) {
-    return "";
+    return { code: "", unmatchedSteps: [], needsAiBehaviors: false };
   }
   const actions = [];
+  const allUnmatchedSteps = [];
   Object.entries(controller.actions).forEach(([actionName, action]) => {
+    const behavior = {
+      preconditions: action.requires || action.preconditions || [],
+      steps: action.steps || [],
+      postconditions: action.ensures || action.postconditions || [],
+      sideEffects: action.publishes || action.events || [],
+      transactional: action.transactional
+    };
+    const ctx = {
+      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
+  };
 }
 function generateActionParams(action) {
   if (!action.parameters || Object.keys(action.parameters).length === 0) {
@@ -391,7 +398,7 @@ ${includes}
       }`;
 }
 function hasEventPublishing(curedOps, controller) {
-  return controller.publishes && Array.isArray(controller.publishes) && controller.publishes.length > 0;
+  return true;
 }
 export {
   generatePrismaController as default

package/dist/libs/instance-factories/services/templates/prisma/service-generator.js

@@ -6,23 +6,27 @@ function generatePrismaService(context) {
   }
   const serviceName = service.name;
   const hasEvents = service.publishes && service.publishes.length > 0 || service.subscribes && service.subscribes.length > 0;
+  const operationsCode = generateOperationsWithHelpers(service);
+  const hasAiBehaviors = /\baiBehaviors\./.test(operationsCode);
+  const usesPrisma = /\bprisma\b/.test(operationsCode);
   return `/**
  * ${serviceName}
  * Abstract business logic service
  * ${service.description || ""}
  */
-
-import { PrismaClient } from '@prisma/client';
-${hasEvents ? `import { eventBus, EventName } from '../events/eventBus.js';` : ""}
-
-const prisma = new PrismaClient();
+${usesPrisma ? `
+import { PrismaClient } from '@prisma/client';` : ""}
+${hasEvents ? `import { eventBus } from '../events/eventBus.js';` : ""}
+${hasAiBehaviors ? `import * as aiBehaviors from '../behaviors/${serviceName}.ai.js';` : ""}
+${usesPrisma ? `
+const prisma = new PrismaClient();` : ""}
 
 /**
  * ${serviceName} class
  */
 export class ${serviceName} {
   ${generateConstructor(service)}
-  ${generateOperationsWithHelpers(service)}
+  ${operationsCode}
   ${generateEventSubscriptions(service)}
 }
 
@@ -97,8 +101,10 @@ function generateOperations(service) {
   return operations.join("\n");
 }
 function generateOperation(operationName, operation, service) {
-  const params = generateOperationParams(operation);
+  const rawParams = generateOperationParams(operation);
   const hasPublish = service.publishes && service.publishes.length > 0;
+  const body = generateOperationLogic(operation, service);
+  const params = renameUnusedParams(rawParams, body);
   return `
   /**
    * ${operationName}
@@ -106,7 +112,7 @@ function generateOperation(operationName, operation, service) {
    */
   public async ${operationName}(${params}): Promise<any> {
     try {
-      ${generateOperationLogic(operation, service)}
+      ${body}
 
       ${hasPublish ? `
       // Publish event (example)
@@ -125,6 +131,19 @@ function generateOperation(operationName, operation, service) {
   }
 `;
 }
+function renameUnusedParams(paramsString, body) {
+  if (!paramsString.trim()) return paramsString;
+  return paramsString.split(",").map((segment) => {
+    const trimmed = segment.trim();
+    const nameMatch = trimmed.match(/^(\w+)/);
+    if (!nameMatch) return segment;
+    const name = nameMatch[1];
+    if (name.startsWith("_")) return segment;
+    const re = new RegExp(`\\b${name}\\b`);
+    if (re.test(body)) return segment;
+    return segment.replace(new RegExp(`\\b${name}\\b`), `_${name}`);
+  }).join(", ");
+}
 function generateOperationParams(operation) {
   if (!operation.parameters || Object.keys(operation.parameters).length === 0) {
     return "params: any = {}";
@@ -149,17 +168,19 @@ function generateOperationLogic(operation, service) {
   }
   if (impl.preconditions?.length || impl.postconditions?.length || impl.steps?.length || impl.transactional) {
     const modelName = inferModelFromServiceName(service.name);
+    const parameterNames = Object.keys(operation.parameters || {});
     const context = {
       modelName,
       serviceName: service.name,
       operationName: operation.name || "execute",
-      prismaModel: modelName
+      prismaModel: modelName,
+      parameterNames
     };
     const behavior = {
       preconditions: impl.preconditions || [],
       postconditions: impl.postconditions || [],
       sideEffects: impl.sideEffects || [],
-      steps: impl.steps || [],
+      steps: impl.steps || operation.steps || [],
       transactional: impl.transactional || false
     };
     const opMeta = {

package/dist/libs/instance-factories/services/templates/prisma/step-conventions.js

@@ -4,15 +4,47 @@ function toVar(name) {
 function toMethod(words) {
   return words.trim().replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toLowerCase());
 }
+function resolveValue(rawValue, ctx) {
+  const value = rawValue.trim().replace(/^['"]|['"]$/g, "");
+  if (/^(current\s*time|now|timestamp)$/i.test(value)) {
+    return "new Date().toISOString()";
+  }
+  if (value === "true" || value === "false") return value;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return value;
+  const declared = ctx.declaredVars || /* @__PURE__ */ new Set();
+  const params = ctx.parameterNames || [];
+  const rootMatch = value.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(\.[a-zA-Z0-9_.]+)?$/);
+  if (rootMatch) {
+    const root = rootMatch[1];
+    if (declared.has(root) || params.includes(root)) {
+      return value;
+    }
+  }
+  const tokens = value.toLowerCase().split(/\s+/);
+  for (const declaredName of [...declared, ...params]) {
+    const normalized = declaredName.toLowerCase();
+    if (tokens.includes(normalized)) return declaredName;
+  }
+  const calcMatch = value.match(/^(?:the\s+|calculated\s+|computed\s+|resulting\s+)(\w+)/i);
+  if (calcMatch) {
+    const field = calcMatch[1];
+    const stepResults = [...declared].filter((v) => /^step\d+Result$/.test(v)).sort().reverse();
+    if (stepResults.length > 0) {
+      return `(${stepResults[0]} as any).${field} /* TODO: verify field name */`;
+    }
+  }
+  if (/\s/.test(value)) {
+    return `/* TODO: resolve "${value}" \u2014 no matching declared variable */ null`;
+  }
+  return `'${value.replace(/'/g, "\\'")}'`;
+}
 const STEP_CONVENTIONS = [
   // --- Validation ---
   {
     name: "validate",
     pattern: /^validate\s+(.+)/i,
     generateCall: (m, ctx) => `    // Step ${ctx.stepNum}: Validate ${m[1]}
-    const validationResult = this.validate(params, { operation: '${ctx.operationName}' });
-    if (!validationResult.valid) {
-      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    // TODO: Add validation logic for ${m[1]}
     }`
   },
   // --- Check / Guard ---
@@ -23,21 +55,9 @@ const STEP_CONVENTIONS = [
       const condition = m[1];
       const methodName = toMethod("check " + condition);
       return `    // Step ${ctx.stepNum}: Check ${condition}
-    const checkResult = await this.${methodName}(params);
-    if (!checkResult) {
-      throw new Error('Check failed: ${condition}');
-    }`;
-    },
-    generateMethod: (m, ctx) => {
-      const condition = m[1];
-      const methodName = toMethod("check " + condition);
-      return `
-  private async ${methodName}(params: any): Promise<boolean> {
     // TODO: Implement check \u2014 ${condition}
-    const ${toVar(ctx.prismaModel)} = await this.prisma.${toVar(ctx.prismaModel)}.findUnique({ where: { id: params.id } });
-    if (!${toVar(ctx.prismaModel)}) return false;
-    return true;
-  }`;
+    // const checkResult = ...
+    // if (!checkResult) throw new Error('Check failed: ${condition}');`;
     }
   },
   // --- Find / Lookup ---
@@ -47,21 +67,29 @@ const STEP_CONVENTIONS = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const field = m[2];
+      const modelVar = toVar(model);
+      const params = ctx.parameterNames || [];
+      const declared = ctx.declaredVars || /* @__PURE__ */ new Set();
+      const idParam = field === "id" ? params.find((p) => p === `${modelVar}Id`) || params.find((p) => p === "id") || `${modelVar}Id` : params.find((p) => p === field) || `params.${field}`;
+      if (declared.has(modelVar)) {
+        return `    // Step ${ctx.stepNum}: Find ${model} by ${field} (already loaded)`;
+      }
+      declared.add(modelVar);
       return `    // Step ${ctx.stepNum}: Find ${model} by ${field}
-    const ${toVar(model)} = await this.prisma.${toVar(model)}.findUnique({ where: { ${field}: params.${field} } });
-    if (!${toVar(model)}) {
-      throw new Error('${model} not found by ${field}');
-    }`;
+    const ${modelVar} = await prisma.${modelVar}.findUniqueOrThrow({ where: { ${field}: ${idParam} } });`;
     }
   },
   // --- Create ---
   {
     name: "create",
-    pattern: /^create\s+(\w+)(?:\s+record)?/i,
+    pattern: /^create\s+(\w+)(?:\s+(?:with\s+)?(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = toVar(model);
+      const paramNames = ctx.parameterNames || [];
+      const dataFields = paramNames.length > 0 ? `{ ${paramNames.join(", ")} }` : "data";
       return `    // Step ${ctx.stepNum}: Create ${model}
-    const ${toVar(model)} = await this.prisma.${toVar(model)}.create({ data: params });`;
+    const ${modelVar} = await prisma.${modelVar}.create({ data: ${dataFields} });`;
     }
   },
   // --- Update field ---
@@ -71,12 +99,12 @@ const STEP_CONVENTIONS = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const field = m[2];
-      const value = m[3].trim().replace(/"/g, "'");
-      const isString = /^[a-z]/.test(value) && !value.includes(".");
-      const val = isString ? `'${value}'` : value;
-      return `    // Step ${ctx.stepNum}: Update ${model} ${field} to ${value}
-    await this.prisma.${toVar(model)}.update({
-      where: { id: params.id },
+      const rawValue = m[3];
+      const modelVar = toVar(model);
+      const val = resolveValue(rawValue, ctx);
+      return `    // Step ${ctx.stepNum}: Update ${model} ${field} to ${rawValue.trim()}
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: ${val} },
     });`;
     }
@@ -87,9 +115,10 @@ const STEP_CONVENTIONS = [
     pattern: /^update\s+(\w+)(?:\s+(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = toVar(model);
       return `    // Step ${ctx.stepNum}: Update ${model}
-    await this.prisma.${toVar(model)}.update({
-      where: { id: params.id },
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: params,
     });`;
     }
@@ -100,8 +129,9 @@ const STEP_CONVENTIONS = [
     pattern: /^delete\s+(\w+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = toVar(model);
       return `    // Step ${ctx.stepNum}: Delete ${model}
-    await this.prisma.${toVar(model)}.delete({ where: { id: params.id } });`;
+    await prisma.${modelVar}.delete({ where: { id: ${modelVar}.id } });`;
     }
   },
   // --- Transition / Evolve ---
@@ -111,11 +141,11 @@ const STEP_CONVENTIONS = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const state = m[2];
+      const modelVar = toVar(model);
       return `    // Step ${ctx.stepNum}: Transition ${model} to ${state}
-    const current = await this.prisma.${toVar(model)}.findUniqueOrThrow({ where: { id: params.id } });
-    // Lifecycle validation would check valid transition here
-    await this.prisma.${toVar(model)}.update({
-      where: { id: params.id },
+    if (${modelVar}.status === '${state}') throw new Error('${model} is already ${state}');
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { status: '${state}' },
     });`;
     }
@@ -126,12 +156,12 @@ const STEP_CONVENTIONS = [
     pattern: /^set\s+(\w+)\s+to\s+(.+)/i,
     generateCall: (m, ctx) => {
       const field = m[1];
-      const value = m[2].trim();
-      const isCurrentTime = /current time|now|timestamp/i.test(value);
-      const val = isCurrentTime ? "new Date()" : `'${value}'`;
-      return `    // Step ${ctx.stepNum}: Set ${field} to ${value}
-    await this.prisma.${toVar(ctx.prismaModel)}.update({
-      where: { id: params.id },
+      const rawValue = m[2];
+      const modelVar = toVar(ctx.prismaModel);
+      const val = resolveValue(rawValue, ctx);
+      return `    // Step ${ctx.stepNum}: Set ${field} to ${rawValue.trim()}
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: ${val} },
     });`;
     }
@@ -143,10 +173,11 @@ const STEP_CONVENTIONS = [
     generateCall: (m, ctx) => {
       const field = m[1];
       const amount = m[2];
-      const amountVal = /^\d+$/.test(amount) ? amount : `params.${amount}`;
+      const modelVar = toVar(ctx.prismaModel);
+      const amountVal = /^\d+$/.test(amount) ? amount : amount;
       return `    // Step ${ctx.stepNum}: Increment ${field} by ${amount}
-    await this.prisma.${toVar(ctx.prismaModel)}.update({
-      where: { id: params.id },
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: { increment: ${amountVal} } },
     });`;
     }
@@ -158,38 +189,18 @@ const STEP_CONVENTIONS = [
     generateCall: (m, ctx) => {
       const field = m[1];
       const amount = m[2];
-      const amountVal = /^\d+$/.test(amount) ? amount : `params.${amount}`;
+      const modelVar = toVar(ctx.prismaModel);
+      const amountVal = /^\d+$/.test(amount) ? amount : amount;
       return `    // Step ${ctx.stepNum}: Decrement ${field} by ${amount}
-    const current${field} = await this.prisma.${toVar(ctx.prismaModel)}.findUniqueOrThrow({ where: { id: params.id } });
-    if ((current${field}.${field} || 0) < ${amountVal}) {
-      throw new Error('Cannot decrement ${field} below zero');
-    }
-    await this.prisma.${toVar(ctx.prismaModel)}.update({
-      where: { id: params.id },
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: { decrement: ${amountVal} } },
     });`;
     }
   },
-  // --- Calculate ---
-  {
-    name: "calculate",
-    pattern: /^calculate\s+(.+)/i,
-    generateCall: (m, ctx) => {
-      const metric = m[1];
-      const methodName = toMethod("calculate " + metric);
-      return `    // Step ${ctx.stepNum}: Calculate ${metric}
-    const ${toVar(metric.replace(/\s+/g, ""))} = await this.${methodName}(params);`;
-    },
-    generateMethod: (m, ctx) => {
-      const metric = m[1];
-      const methodName = toMethod("calculate " + metric);
-      return `
-  private async ${methodName}(params: any): Promise<number> {
-    // TODO: Implement calculation \u2014 ${metric}
-    return 0;
-  }`;
-    }
-  },
+  // NOTE: "calculate X" is intentionally NOT a convention — it falls through to AI
+  // behaviors because calculations are domain-specific pure functions that benefit
+  // from AI generation with the full input context.
   // --- Send event ---
   {
     name: "send-event",
@@ -197,7 +208,7 @@ const STEP_CONVENTIONS = [
     generateCall: (m, ctx) => {
       const event = m[1];
       return `    // Step ${ctx.stepNum}: Emit ${event} event
-    this.emit('${event}', { ${toVar(ctx.prismaModel)}Id: params.id, operation: '${ctx.operationName}', timestamp: new Date().toISOString() });`;
+    await eventBus.publish('${event}', { ${toVar(ctx.prismaModel)}Id: ${toVar(ctx.prismaModel)}.id, operation: '${ctx.operationName}', timestamp: new Date().toISOString() });`;
     }
   },
   // --- Send notification ---
@@ -207,7 +218,7 @@ const STEP_CONVENTIONS = [
     generateCall: (m, ctx) => {
       const type = m[1];
       return `    // Step ${ctx.stepNum}: Send ${type} notification
-    this.emit('${type}Notification', { ${toVar(ctx.prismaModel)}Id: params.id, operation: '${ctx.operationName}' });`;
+    await eventBus.publish('${type}Notification', { ${toVar(ctx.prismaModel)}Id: ${toVar(ctx.prismaModel)}.id, operation: '${ctx.operationName}' });`;
     }
   },
   // --- Call service ---
@@ -218,7 +229,7 @@ const STEP_CONVENTIONS = [
       const service = m[1];
       const method = m[2];
       return `    // Step ${ctx.stepNum}: Call ${service}.${method}
-    await this.${toVar(service)}.${method}(params);`;
+    await ${toVar(service)}.${method}({ ${(ctx.parameterNames || []).join(", ")} });`;
     }
   },
   // --- Return ---
@@ -243,19 +254,25 @@ function matchStep(step, ctx) {
     if (match) {
       return {
         call: convention.generateCall(match, ctx),
-        helperMethod: convention.generateMethod?.(match, ctx)
+        helperMethod: convention.generateMethod?.(match, ctx),
+        matched: true
       };
     }
   }
-  const methodName = toMethod(step);
+  const functionName = toMethod(step);
+  const declared = Array.from(ctx.declaredVars || []);
+  const paramNames = ctx.parameterNames || [];
+  const inputs = [...paramNames, ...declared];
+  const resultVar = ctx.resultName || `step${ctx.stepNum}Result`;
+  const inputObj = inputs.length > 0 ? `{ ${inputs.join(", ")} }` : "{}";
+  if (ctx.declaredVars) ctx.declaredVars.add(resultVar);
   return {
-    call: `    // Step ${ctx.stepNum}: ${step}
-    await this.${methodName}(params);`,
-    helperMethod: `
-  private async ${methodName}(params: any): Promise<void> {
-    // TODO: Implement \u2014 ${step}
-    throw new Error('Not implemented: ${methodName}');
-  }`
+    call: `    // Step ${ctx.stepNum}: ${step} [AI-generated \u2014 pure function]
+    const ${resultVar} = await aiBehaviors.${functionName}(${inputObj});`,
+    matched: false,
+    functionName,
+    inputs,
+    resultVar
   };
 }
 export {