@specverse/engines 4.1.12 → 4.1.14

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

@@ -0,0 +1,141 @@
+import { matchStep } from "./step-conventions.js";
+async function generateAiBehaviors(context) {
+  const { controller, model } = context;
+  if (!controller?.actions) return "";
+  const modelName = model?.name || controller.model || "Model";
+  const modelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+  const unmatchedFunctions = [];
+  for (const [actionName, action] of Object.entries(controller.actions)) {
+    const steps = action.steps || [];
+    const parameterNames = Object.keys(action.parameters || {});
+    const preconditions = action.requires || action.preconditions || [];
+    const declaredVars = /* @__PURE__ */ new Set();
+    for (const pc of preconditions) {
+      const match = pc.match(/^(\w+)\s+(?:exists|is\s+\w+)$/i);
+      if (match) {
+        const entity = match[1];
+        declaredVars.add(entity.charAt(0).toLowerCase() + entity.slice(1));
+      }
+    }
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      if (typeof step !== "string") continue;
+      const ctx = {
+        modelName,
+        prismaModel: modelVar,
+        serviceName: `${modelName}Controller`,
+        operationName: actionName,
+        stepNum: i + 1,
+        parameterNames,
+        declaredVars
+      };
+      const result = matchStep(step, ctx);
+      if (!result.matched && result.functionName) {
+        const existing = unmatchedFunctions.find((f) => f.functionName === result.functionName);
+        if (!existing) {
+          unmatchedFunctions.push({
+            functionName: result.functionName,
+            step,
+            operationName: actionName,
+            parameterNames,
+            inputs: result.inputs || []
+          });
+        }
+      }
+    }
+  }
+  if (unmatchedFunctions.length === 0) return "";
+  let aiService = null;
+  try {
+    const { BehaviorAIService } = await import("@specverse/engines/ai");
+    aiService = new BehaviorAIService();
+    if (!aiService.isAvailable) {
+      aiService = null;
+    } else {
+      aiService.startSession(`${modelName}Controller`);
+    }
+  } catch {
+    aiService = null;
+  }
+  const availableModels = context.spec?.models ? Object.keys(context.spec.models) : [];
+  const functions = [];
+  for (const { functionName, step, operationName, parameterNames, inputs } of unmatchedFunctions) {
+    const signature = inputs.length > 0 ? `input: { ${inputs.map((n) => `${n}: any`).join("; ")} }` : "input: Record<string, never>";
+    const destructure = inputs.length > 0 ? `  const { ${inputs.join(", ")} } = input;` : "";
+    let body = null;
+    let source = "STUB";
+    if (aiService) {
+      try {
+        body = await aiService.generateBehavior({
+          step,
+          modelName,
+          operationName,
+          functionName,
+          parameterNames: inputs,
+          // the actual inputs to the pure function
+          availableModels,
+          spec: context.spec
+        });
+        if (body) source = "AI-GENERATED";
+      } catch {
+      }
+    }
+    if (!body) {
+      body = `  throw new Error('Not implemented: ${functionName} \u2014 see behaviors/${modelName}Controller.ai.ts');`;
+    } else {
+      body = body.split("\n").map((line) => line ? "  " + line : line).join("\n");
+    }
+    const inputsDoc = inputs.length > 0 ? ` * Inputs: ${inputs.join(", ")}
+` : "";
+    functions.push(`/**
+ * ${functionName}
+ *
+ * Spec step: "${step}"
+ * Called by: ${modelName}Controller.${operationName}()
+${inputsDoc} * Source: ${source}
+ * Generated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+ *
+ * PURE FUNCTION \u2014 no database access, no event publishing, no external services.
+ * All data comes in via \`input\`; all effects happen in the calling controller.
+ * ${source === "AI-GENERATED" ? "AI-generated implementation. Review and test before deploying." : "STUB \u2014 Claude CLI unavailable. Install Claude Code or implement manually."}
+ */
+export async function ${functionName}(${signature}): Promise<any> {
+${destructure ? destructure + "\n" : ""}${body}
+}`);
+  }
+  if (aiService?.endSession) aiService.endSession();
+  return `/**
+ * ${modelName}Controller \u2014 AI-Generated Behaviors
+ *
+ * \u26A0\uFE0F  THIS FILE CONTAINS STUBS FOR STEPS THAT NEED IMPLEMENTATION
+ *
+ * These functions could not be generated from convention patterns.
+ * They are called by ${modelName}Controller when executing custom actions.
+ *
+ * Options for each function:
+ * - Implement manually (recommended for business-critical logic)
+ * - Use AI generation: specverse ai generate <function>
+ * - Refactor the spec step to use a convention pattern
+ *
+ * Convention patterns that ARE auto-generated (no AI needed):
+ *   "Find {Model} by {field}" \u2192 prisma.model.findUniqueOrThrow(...)
+ *   "Create {Model}" \u2192 prisma.model.create(...)
+ *   "Update {Model} {field} to {value}" \u2192 prisma.model.update(...)
+ *   "Delete {Model}" \u2192 prisma.model.delete(...)
+ *   "Transition {Model} to {state}" \u2192 prisma.model.update({ status: ... })
+ *   "Count {Model}s per {Group}" \u2192 prisma.model.groupBy(...)
+ *   See step-conventions.ts for the full list.
+ *
+ * Generated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+ */
+
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+${functions.join("\n\n")}
+`;
+}
+export {
+  generateAiBehaviors as default
+};

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