@specverse/engines 4.1.13 → 4.1.14

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

@@ -6,14 +6,17 @@ function generateBehaviorBody(behavior, opMeta, context) {
 function generateBehaviorWithHelpers(behavior, opMeta, context) {
   const parts = [];
   const helperMethods = [];
+  const preconditionDeclared = /* @__PURE__ */ new Set();
   const preconditions = generatePreconditionChecks(
     behavior.preconditions || [],
-    context
+    context,
+    preconditionDeclared
   );
   if (preconditions) parts.push(preconditions);
-  const { code, helpers } = generateStepLogic(
+  const { code, helpers, unmatchedSteps } = generateStepLogic(
     behavior.steps || [],
-    context
+    context,
+    preconditionDeclared
   );
   parts.push(code);
   helperMethods.push(...helpers);
@@ -23,76 +26,80 @@ function generateBehaviorWithHelpers(behavior, opMeta, context) {
   if (postconditions) parts.push(postconditions);
   const events = generateEventPublishing(
     behavior.sideEffects || [],
-    context.operationName
+    context.operationName,
+    context.parameterNames
   );
   if (events) parts.push(events);
   let body = parts.join("\n\n");
   if (behavior.transactional) {
     body = generateTransactionWrapper(body, context);
   }
-  return { body, helperMethods };
+  return { body, helperMethods, unmatchedSteps };
 }
-function generatePreconditionChecks(preconditions, context) {
+function generatePreconditionChecks(preconditions, context, declared) {
   if (preconditions.length === 0) return "";
-  const checks = preconditions.map((pc) => matchPreconditionPattern(pc, context));
+  if (!declared) declared = /* @__PURE__ */ new Set();
+  const checks = preconditions.map((pc) => matchPreconditionPattern(pc, context, declared));
   return `    // === PRECONDITIONS ===
 ${checks.join("\n")}`;
 }
-function matchPreconditionPattern(precondition, context) {
+function findIdParam(modelName, paramNames) {
+  const modelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+  const idParam = paramNames.find((p) => p === `${modelVar}Id`);
+  if (idParam) return idParam;
+  if (paramNames.includes("id")) return "id";
+  return `${modelVar}Id`;
+}
+function matchPreconditionPattern(precondition, context, declared) {
   const pc = precondition.toLowerCase();
-  const prismaModel = context.prismaModel || context.modelName;
+  const params = context.parameterNames || [];
   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)) {
+      return `    // Guard: ${precondition} (already fetched)`;
+    }
+    declared.add(entityVar);
+    return `    const ${entityVar} = await prisma.${entityVar}.findUniqueOrThrow({ where: { id: ${idParam} } });`;
   }
   if (pc.includes("is not empty") || pc.includes("is required")) {
     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');`;
     }
   }
   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} \u2014 ' + validation.errors.join(', '));
-    }`;
+    return `    // TODO: Implement validation: ${precondition}`;
   }
   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]}');`;
   }
   const stateMatch = precondition.match(/^(\w+)\s+is\s+(\w+)$/i);
   if (stateMatch) {
     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 (!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);`;
   }
-  return `    // Guard: ${precondition}
-    // TODO: Implement precondition check`;
+  return `    // TODO: Implement precondition: ${precondition}`;
 }
-function generateStepLogic(steps, context) {
+function generateStepLogic(steps, context, preconditionDeclared) {
   const helpers = [];
+  const unmatchedSteps = [];
+  const declaredVars = preconditionDeclared || /* @__PURE__ */ new Set();
   if (steps && steps.length > 0) {
     const stepCode = steps.map((step, i) => {
       if (typeof step !== "string") {
@@ -103,24 +110,36 @@ function generateStepLogic(steps, context) {
         prismaModel: context.prismaModel || context.modelName,
         serviceName: context.serviceName,
         operationName: context.operationName,
-        stepNum: i + 1
+        stepNum: i + 1,
+        parameterNames: context.parameterNames,
+        declaredVars
       };
       const result = matchStep(step, ctx);
       if (result.helperMethod) {
         helpers.push(result.helperMethod);
       }
+      if (!result.matched && result.functionName) {
+        unmatchedSteps.push({
+          step,
+          functionName: result.functionName,
+          operationName: context.operationName,
+          inputs: result.inputs || []
+        });
+      }
       return result.call;
     });
     return {
       code: `    // === EXECUTE ===
 ${stepCode.join("\n\n")}`,
-      helpers
+      helpers,
+      unmatchedSteps
     };
   }
   return {
     code: `    // === EXECUTE ===
 ${inferLogicFromOperationName(context)}`,
-    helpers
+    helpers,
+    unmatchedSteps
   };
 }
 function inferLogicFromOperationName(context) {
@@ -154,10 +173,11 @@ function generatePostconditionVerification(postconditions) {
 ${checks.join("\n")}
     }`;
 }
-function generateEventPublishing(sideEffects, operationName) {
+function generateEventPublishing(sideEffects, operationName, parameterNames) {
   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() });`
+    (event) => `    await eventBus.publish('${event}', { ${paramFields}timestamp: new Date().toISOString() });`
   );
   return `    // === EVENTS ===
 ${publishes.join("\n")}`;

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) {
@@ -16,6 +17,7 @@ function generatePrismaController(context) {
   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 +25,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();
 
@@ -42,7 +45,7 @@ export class ${controllerName} {
   ${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)}
+  ${customActions.code}
 }
 
 // Export singleton instance
@@ -298,21 +301,44 @@ function generateDeleteMethod(model, modelName, modelVar, controller) {
 }
 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 +417,13 @@ ${includes}
       }`;
 }
 function hasEventPublishing(curedOps, controller) {
-  return controller.publishes && Array.isArray(controller.publishes) && controller.publishes.length > 0;
+  if (controller.publishes && Array.isArray(controller.publishes) && controller.publishes.length > 0) return true;
+  if (controller.actions) {
+    for (const action of Object.values(controller.actions)) {
+      if (action.publishes?.length > 0 || action.events?.length > 0 || action.sideEffects?.length > 0) return true;
+    }
+  }
+  return false;
 }
 export {
   generatePrismaController as default

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 = `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 {

package/dist/realize/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/realize/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,kBAAkB,CAAC;AAGjC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,uBAAuB,CAAC;AAGtC,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAMlE,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AASnF,cAAM,sBAAuB,YAAW,aAAa;IACnD,IAAI,SAAa;IACjB,OAAO,SAAW;IAClB,YAAY,WAA+E;IAE3F,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,WAAW,CAAS;IAEtB,UAAU,CAAC,MAAM,CAAC,EAAE;QACxB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBjB,OAAO,IAAI,UAAU;IAIrB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG;IAK1B,QAAQ,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAKvF;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAua9F;;;OAGG;YACW,UAAU;IAwDxB,OAAO,CAAC,oBAAoB;CAuB7B;AAED,eAAO,MAAM,MAAM,wBAA+B,CAAC;AACnD,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/realize/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,kBAAkB,CAAC;AAGjC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,uBAAuB,CAAC;AAGtC,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAMlE,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AASnF,cAAM,sBAAuB,YAAW,aAAa;IACnD,IAAI,SAAa;IACjB,OAAO,SAAW;IAClB,YAAY,WAA+E;IAE3F,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,WAAW,CAAS;IAEtB,UAAU,CAAC,MAAM,CAAC,EAAE;QACxB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBjB,OAAO,IAAI,UAAU;IAIrB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG;IAK1B,QAAQ,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAKvF;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IA4d9F;;;OAGG;YACW,UAAU;IAwDxB,OAAO,CAAC,oBAAoB;CAuB7B;AAED,eAAO,MAAM,MAAM,wBAA+B,CAAC;AACnD,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,CAAC"}