@specverse/engines 6.7.8 → 6.16.0

package/dist/libs/instance-factories/applications/templates/generic/backend-package-json-generator.js

@@ -12,7 +12,10 @@ function generateBackendPackageJson(context) {
   const appName = (spec.metadata?.component || "app").toLowerCase().replace(/\s+/g, "-");
   const orm = resolveOrmName(manifest);
   const isMongoNative = orm === "MongoDBNativeDriver";
-  const dbScripts = isMongoNative ? {} : {
+  const isPgNative = orm === "PostgresNativeDriver";
+  const dbScripts = isMongoNative ? {} : isPgNative ? {
+    "db:setup": 'psql "$POSTGRES_URL" -f src/db/schema.sql'
+  } : {
     "db:setup": "prisma generate && prisma db push",
     "db:generate": "prisma generate",
     "db:push": "prisma db push",
@@ -20,8 +23,8 @@ function generateBackendPackageJson(context) {
     "db:studio": "prisma studio",
     "db:seed": "tsx prisma/seed.ts"
   };
-  const ormDeps = isMongoNative ? { "mongodb": "^6.3.0" } : { "@prisma/client": "^5.7.0" };
-  const ormDevDeps = isMongoNative ? {} : { "prisma": "^5.7.0" };
+  const ormDeps = isMongoNative ? { "mongodb": "^6.3.0" } : isPgNative ? { "pg": "^8.11.0" } : { "@prisma/client": "^5.7.0" };
+  const ormDevDeps = isMongoNative ? {} : isPgNative ? { "@types/pg": "^8.11.0" } : { "prisma": "^5.7.0" };
   const pkg = {
     name: `${appName}-backend`,
     version: spec.metadata?.version || "1.0.0",
@@ -61,7 +64,17 @@ function generateBackendPackageJson(context) {
       "eventemitter3": "^5.0.0",
       "zod": "^3.22.0",
       "dotenv": "^16.3.0",
-      "commander": "^13.0.0"
+      "commander": "^13.0.0",
+      // AI-behavior whitelist — these libs are allowed to be dynamic-
+      // imported from generated `*.ai.ts` pure functions. They cover the
+      // common cases (JWT, hashing, formula eval) without giving the LLM
+      // unbounded library access. Listed unconditionally for now; revisit
+      // (TODO #43K-B-review) whether to gate per-spec when the spec
+      // doesn't actually use them.
+      "jsonwebtoken": "^9.0.0",
+      "bcryptjs": "^2.4.3",
+      "uuid": "^9.0.0",
+      "expr-eval": "^2.0.2"
     },
     devDependencies: {
       "typescript": "^5.3.0",
@@ -72,7 +85,11 @@ function generateBackendPackageJson(context) {
       "@vitest/coverage-v8": "^3.0.0",
       "eslint": "^9.0.0",
       "@typescript-eslint/eslint-plugin": "^8.0.0",
-      "@typescript-eslint/parser": "^8.0.0"
+      "@typescript-eslint/parser": "^8.0.0",
+      // Type definitions for the AI-behavior whitelist libs (#43K-B).
+      "@types/jsonwebtoken": "^9.0.0",
+      "@types/bcryptjs": "^2.4.0",
+      "@types/uuid": "^9.0.0"
     },
     engines: {
       node: ">=20.0.0"

package/dist/libs/instance-factories/controllers/templates/fastify/routes-generator.js

@@ -21,10 +21,14 @@ function generateFastifyRoutes(context) {
     for (const [actionName, action] of Object.entries(controller.actions)) {
       const params = action.parameters || {};
       const hasIdParam = Object.keys(params).some((p) => p === "id" || p === `${modelName?.charAt(0).toLowerCase()}${modelName?.slice(1)}Id`);
+      const explicitPath = action.path;
+      const explicitMethod = action.method;
+      const isExternal = !!(explicitPath && /^\/api\//.test(explicitPath));
       endpoints.push({
         operation: actionName,
-        method: "POST",
-        path: hasIdParam ? `/:id/${actionName}` : `/${actionName}`,
+        method: explicitMethod || "POST",
+        path: explicitPath || (hasIdParam ? `/:id/${actionName}` : `/${actionName}`),
+        external: isExternal,
         parameters: params,
         description: action.description || `Custom action: ${actionName}`
       });
@@ -33,9 +37,27 @@ function generateFastifyRoutes(context) {
   if (!endpoints || endpoints.length === 0) {
     console.warn(`Warning: Controller ${controllerName} has no endpoints. Generating empty routes file.`);
   }
-  const routeHandlers = endpoints?.map((endpoint) => {
-    return generateRouteHandler(endpoint, modelName, handlerName, isModelController, implType, controllerName);
-  }).join("\n\n") || "";
+  const internalEndpoints = endpoints?.filter((e) => !e.external) || [];
+  const externalEndpoints = endpoints?.filter((e) => e.external) || [];
+  const internalHandlers = internalEndpoints.map((endpoint) => generateRouteHandler(endpoint, modelName, handlerName, isModelController, implType, controllerName)).join("\n\n");
+  const externalHandlers = externalEndpoints.map((endpoint) => generateRouteHandler(endpoint, modelName, handlerName, isModelController, implType, controllerName)).join("\n\n");
+  const externalRoutesExport = externalEndpoints.length > 0 ? `
+/**
+ * Mount the external (root-prefix) routes for this controller.
+ *
+ * Called by the generated main.ts at root scope (no prefix) so action.path
+ * declarations like '/api/v2/auth/register' land at exactly that URL,
+ * bypassing the controller's '/api/<plural>' prefix.
+ */
+export async function registerExternalRoutes(
+  fastify: FastifyInstance,
+  options: any
+) {
+  const handler = ${isModelController ? "options.controllers" : "options.services"}.${handlerName};
+
+${externalHandlers.split("\n").map((line) => "  " + line).join("\n")}
+}
+` : "";
   return `${imports}
 
 /**
@@ -51,9 +73,9 @@ export default async function ${routeName.replace("Controller", "")}Routes(
 ) {
   const handler = ${isModelController ? "options.controllers" : "options.services"}.${handlerName};
 
-${routeHandlers.split("\n").map((line) => "  " + line).join("\n")}
+${internalHandlers.split("\n").map((line) => "  " + line).join("\n")}
 }
-`;
+${externalRoutesExport}`;
 }
 function generateImports(controller, modelName, handlerName, isModelController, implType) {
   const imports = [
@@ -226,36 +248,49 @@ function generateHandlerBody(operation, modelName, handlerName, isModelControlle
   });
 }`;
     default: {
+      const path = endpoint?.path || "";
+      const urlParamNames = /* @__PURE__ */ new Set();
+      const urlParamRegex = /:([A-Za-z_][\w]*)/g;
+      let urlMatch;
+      while ((urlMatch = urlParamRegex.exec(path)) !== null) {
+        urlParamNames.add(urlMatch[1]);
+      }
       const params = endpoint?.parameters || {};
-      const paramNames = Object.keys(params);
-      const callArgs = paramNames.length > 0 ? paramNames.map((p) => `body.${p}`).join(", ") : "body";
       const validations = [];
       for (const [pName, pDef] of Object.entries(params)) {
+        if (urlParamNames.has(pName)) continue;
         const required = typeof pDef === "string" ? pDef.includes("required") : pDef?.required;
         const typeStr = typeof pDef === "string" ? pDef.split(" ")[0] : pDef?.type || "String";
         if (required) {
-          validations.push(`  if (body.${pName} === undefined || body.${pName} === null) errors.push({ field: '${pName}', message: '${pName} is required' });`);
+          validations.push(`  if (args.${pName} === undefined || args.${pName} === null) errors.push({ field: '${pName}', message: '${pName} is required' });`);
         }
         if (typeStr === "UUID" || typeStr === "String" || typeStr === "Email") {
-          validations.push(`  if (body.${pName} !== undefined && typeof body.${pName} !== 'string') errors.push({ field: '${pName}', message: '${pName} must be a string' });`);
+          validations.push(`  if (args.${pName} !== undefined && typeof args.${pName} !== 'string') errors.push({ field: '${pName}', message: '${pName} must be a string' });`);
         } else if (typeStr === "Integer" || typeStr === "Number" || typeStr === "Float") {
-          validations.push(`  if (body.${pName} !== undefined && typeof body.${pName} !== 'number') errors.push({ field: '${pName}', message: '${pName} must be a number' });`);
+          validations.push(`  if (args.${pName} !== undefined && typeof args.${pName} !== 'number') errors.push({ field: '${pName}', message: '${pName} must be a number' });`);
         } else if (typeStr === "Boolean") {
-          validations.push(`  if (body.${pName} !== undefined && typeof body.${pName} !== 'boolean') errors.push({ field: '${pName}', message: '${pName} must be a boolean' });`);
+          validations.push(`  if (args.${pName} !== undefined && typeof args.${pName} !== 'boolean') errors.push({ field: '${pName}', message: '${pName} must be a boolean' });`);
         }
       }
       const validationBlock = validations.length > 0 ? `  const errors: Array<{ field: string; message: string }> = [];
 ${validations.join("\n")}
   if (errors.length > 0) return reply.status(400).send({ error: 'Validation failed', details: errors });` : "";
       return `try {
+  const params = (request.params || {}) as Record<string, any>;
   const body = (request.body || {}) as Record<string, any>;
+  const args = { ...params, ...body };
 ${validationBlock}
-  const result = await handler.${operation}(${callArgs});
+  const result = await handler.${operation}(args);
   return reply.send(result || { success: true });
 } catch (error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  // 501 for TODO-stubbed action bodies (#43F); 400 for real failures.
+  if (msg.includes('is not implemented')) {
+    return reply.status(501).send({ error: 'Not Implemented', message: msg });
+  }
   return reply.status(400).send({
     error: 'Failed to execute ${operation}',
-    message: error instanceof Error ? error.message : String(error)
+    message: msg
   });
 }`;
     }

package/dist/libs/instance-factories/controllers/templates/fastify/server-generator.js

@@ -1,15 +1,31 @@
 import { normalizeSpec, deriveBasePath } from "@specverse/types/spec-rules";
+function resolveOrmName(manifest) {
+  if (!manifest) return "PrismaORM";
+  const inner = manifest.manifests ? Object.values(manifest.manifests)[0] : manifest;
+  if (!inner) return "PrismaORM";
+  const caps = Array.isArray(inner.capabilityMappings) ? inner.capabilityMappings : [];
+  const ormCap = caps.find((m) => m?.capability === "orm.client") || caps.find((m) => m?.capability === "orm.schema");
+  if (ormCap) return ormCap.implementation || ormCap.instanceFactory || "PrismaORM";
+  return inner.defaultMappings?.orm || "PrismaORM";
+}
 function generateFastifyServer(context) {
-  const { spec, models } = context;
+  const { spec, models, manifest } = context;
+  const orm = resolveOrmName(manifest);
+  const isMongoNative = orm === "MongoDBNativeDriver";
   const allModels = models || (spec?.models ? Object.values(spec.models) : []);
   const modelNames = allModels.map((m) => m.name).filter(Boolean);
   const routeImports = modelNames.map(
-    (name) => `import ${name}Routes from './routes/${name}Controller.js';`
+    (name) => `import ${name}Routes, * as ${name}RoutesNS from './routes/${name}Controller.js';`
   ).join("\n");
   const routeRegistrations = modelNames.map((name) => {
     const path = deriveBasePath(name);
     return `  await fastify.register(${name}Routes, { prefix: '${path}', controllers: { ${name}Controller: new (await import('./controllers/${name}Controller.js')).${name}Controller() } });`;
   }).join("\n");
+  const externalRouteRegistrations = modelNames.map((name) => {
+    return `  if (typeof (${name}RoutesNS as any).registerExternalRoutes === 'function') {
+    await (${name}RoutesNS as any).registerExternalRoutes(fastify, { controllers: { ${name}Controller: new (await import('./controllers/${name}Controller.js')).${name}Controller() } });
+  }`;
+  }).join("\n");
   const specEvents = spec.events ? Object.keys(spec.events) : [];
   const hasEvents = specEvents.length > 0 || modelNames.length > 0;
   const servicesList = spec.services ? Object.keys(spec.services) : [];
@@ -52,12 +68,13 @@ import { fileURLToPath } from 'url';
 
 import Fastify from 'fastify';
 import cors from '@fastify/cors';
-import { PrismaClient } from '@prisma/client';
+${isMongoNative ? `import { disconnect as disconnectMongo } from './db/mongoClient.js';` : `import { PrismaClient } from '@prisma/client';`}
 ${hasEvents ? `import { eventBus } from './events/eventBus.js';
 import { registerWebSocketBridge } from './events/websocket-bridge.js';` : ""}
 
-// Initialize Prisma
-export const prisma = new PrismaClient();
+${isMongoNative ? `// MongoDB native driver client lives in db/mongoClient.ts; nothing
+// to initialize at module scope (lazy-connect on first getCollection).` : `// Initialize Prisma
+export const prisma = new PrismaClient();`}
 
 // Initialize Fastify
 const fastify = Fastify({
@@ -99,6 +116,9 @@ ${serviceRouteImports}` : ""}
 async function registerRoutes() {
 ${routeRegistrations}
 ${serviceRouteRegistrations ? "\n  // Service operation routes (RPC-style under /api/services/{ServiceName})\n" + serviceRouteRegistrations : ""}
+
+  // External-prefix actions (action.path declarations like '/api/v2/auth/register')
+${externalRouteRegistrations}
 }
 
 // Start server
@@ -127,7 +147,7 @@ ${hasEvents ? `    console.log(\`WebSocket: ws://localhost:\${port}/ws\`);
       try {
         fastify.log.info(\`Received \${signal}, closing server...\`);
         await fastify.close();
-        try { await (prisma as any).$disconnect?.(); } catch { /* ignore */ }
+        try { ${isMongoNative ? "await disconnectMongo();" : "await (prisma as any).$disconnect?.();"} } catch { /* ignore */ }
         process.exit(0);
       } catch (err) {
         fastify.log.error({ err }, 'Error during shutdown');

package/dist/libs/instance-factories/services/postgres-native-services.yaml

@@ -0,0 +1,90 @@
+name: PostgresNativeDriver
+version: "1.0.0"
+category: service
+description: "Business logic services using the native node-postgres (pg) driver — raw SQL, no ORM layer"
+
+metadata:
+  author: "SpecVerse Team"
+  license: "MIT"
+  tags: [services, business-logic, postgres, pg, native-driver, controllers]
+
+compatibility:
+  specverse: ">=5.0.0"
+  node: ">=18.0.0"
+
+# Same shape as MongoDBNativeDriver — the pg pool IS the data layer; no ORM
+# layer to swap in independently. This single factory therefore provides
+# both the orm.* capabilities and the service-layer capabilities.
+capabilities:
+  provides:
+    - "orm.schema"     # Emits the pg pool client + DDL (the connection IS the schema layer)
+    - "orm.client"
+    - "orm.postgres.native"
+    - "service.controller"
+    - "service.business"
+    - "service.crud"
+  requires:
+    - "storage.database.relational"
+
+technology:
+  runtime: "node"
+  language: "typescript"
+  orm: "postgres-native"
+  version: "^8.11.0"
+
+dependencies:
+  runtime:
+    - name: "pg"
+      version: "^8.11.0"
+
+  dev:
+    - name: "@types/pg"
+      version: "^8.11.0"
+    - name: "@types/node"
+      version: "^20.8.0"
+    - name: "typescript"
+      version: "^5.2.0"
+
+codeTemplates:
+  # `schema` slot emits the pg pool singleton + a co-located CREATE TABLE
+  # script (schema.sql) so users can bootstrap a database without pulling
+  # in an external migrator. The pool generator owns the runtime
+  # connection; the DDL generator owns the static SQL.
+  schema:
+    engine: typescript
+    generator: "libs/instance-factories/services/templates/postgres-native/client-generator.ts"
+    outputPattern: "{backendDir}/src/db/pgClient.ts"
+
+  ddl:
+    engine: typescript
+    generator: "libs/instance-factories/services/templates/postgres-native/ddl-generator.ts"
+    outputPattern: "{backendDir}/src/db/schema.sql"
+
+  controllers:
+    engine: typescript
+    generator: "libs/instance-factories/services/templates/postgres-native/controller-generator.ts"
+    outputPattern: "{backendDir}/src/controllers/{model}Controller.ts"
+
+  services:
+    engine: typescript
+    generator: "libs/instance-factories/services/templates/postgres-native/service-generator.ts"
+    outputPattern: "{backendDir}/src/services/{service}.ts"
+
+configuration:
+  outputStructure: "monorepo"
+  backendDir: "backend"
+  tableNaming: "lowercase-pluralized"  # User → users, OrderItem → orderitems
+  validation: true
+  eventPublishing: true
+  errorHandling: "throw"
+
+requirements:
+  dependencies:
+    npm:
+      dependencies:
+        "pg": "^8.11.0"
+  environment:
+    - name: "POSTGRES_URL"
+      description: "PostgreSQL connection string (e.g. postgres://user:pass@localhost:5432/myapp)"
+      required: true
+  configuration: {}

package/dist/libs/instance-factories/services/templates/_shared/step-matching.js

@@ -0,0 +1,44 @@
+function toMethod(words) {
+  const cleaned = words.trim().replace(/[^A-Za-z0-9\s]+/g, " ");
+  const camel = cleaned.replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toLowerCase());
+  const safe = camel.replace(/[^A-Za-z0-9_$]/g, "");
+  return safe || "unnamedStep";
+}
+function toVar(name) {
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function matchAgainstConventions(step, ctx, conventions, aiArgsExpr) {
+  for (const convention of conventions) {
+    const m = step.match(convention.pattern);
+    if (m) {
+      const call = convention.generateCall(m, ctx);
+      if (call) {
+        return {
+          matched: true,
+          call,
+          helperMethod: convention.generateMethod?.(m, ctx)
+        };
+      }
+    }
+  }
+  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`;
+  if (ctx.declaredVars) ctx.declaredVars.add(resultVar);
+  const inputObj = aiArgsExpr(inputs, paramNames);
+  return {
+    matched: false,
+    call: `    // Step ${ctx.stepNum}: ${step} [AI-generated \u2014 pure transform]
+    const ${resultVar} = await aiBehaviors.${functionName}(${inputObj});`,
+    functionName,
+    inputs,
+    resultVar
+  };
+}
+export {
+  matchAgainstConventions,
+  toMethod,
+  toVar
+};

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

@@ -1,6 +1,6 @@
 import { buildTransitionMap, isAutoField } from "@specverse/types/spec-rules";
 function generateMongoNativeController(context) {
-  const { controller, model } = context;
+  const { controller, model, models } = context;
   if (!controller) throw new Error("Controller is required in template context");
   if (!model) throw new Error("Model is required for controller generation");
   const controllerName = controller.name;
@@ -8,7 +8,13 @@ function generateMongoNativeController(context) {
   const modelVar = lowerFirst(modelName);
   const collection = collectionName(model);
   const curedOps = controller.cured || {};
-  const customActions = generateCustomActions(controller);
+  const modelRegistry = {};
+  if (Array.isArray(models)) {
+    for (const m of models) if (m?.name) modelRegistry[m.name] = m;
+  } else if (models && typeof models === "object") {
+    Object.assign(modelRegistry, models);
+  }
+  const customActions = generateCustomActions(controller, modelRegistry);
   const validate = generateValidateMethod(model, modelName);
   const create = curedOps.create ? generateCreateMethod(model, modelName, modelVar, collection) : "";
   const retrieve = curedOps.retrieve ? generateRetrieveMethod(modelName, modelVar, collection) : "";
@@ -23,7 +29,8 @@ function generateMongoNativeController(context) {
  */
 import { ObjectId, type Filter, type Document } from 'mongodb';
 import { getCollection } from '../db/mongoClient.js';
-${hasEventPublishing ? `import { eventBus } from '../events/eventBus.js';` : ""}
+${hasEventPublishing || customActions.needsAiBehaviors ? `import { eventBus } from '../events/eventBus.js';` : ""}
+${customActions.needsAiBehaviors ? `import * as aiBehaviors from '../behaviors/${controllerName}.ai.js';` : ""}
 
 const COLLECTION_NAME = '${collection}';
 
@@ -221,13 +228,65 @@ function generateDeleteMethod(modelName, modelVar, collection) {
   }
 `;
 }
-function generateCustomActions(controller) {
+import { matchMongoStep } from "./step-conventions.js";
+function generateCustomActions(controller, modelRegistry = {}) {
   if (!controller.actions || Object.keys(controller.actions).length === 0) {
-    return { code: "" };
+    return { code: "", needsAiBehaviors: false };
   }
+  const CRUD_NAMES = /* @__PURE__ */ new Set(["create", "retrieve", "retrieveAll", "update", "evolve", "delete", "validate"]);
+  const modelName = controller.model || (controller.name || "").replace(/Controller$/, "") || "Model";
+  const collectionName2 = modelName.toLowerCase() + "s";
   const out = [];
+  let needsAiBehaviors = false;
   for (const [actionName, action] of Object.entries(controller.actions)) {
-    const stepsHeader = action.steps && action.steps.length > 0 ? action.steps.map((s) => `   *   - ${typeof s === "string" ? s : s.action || JSON.stringify(s)}`).join("\n") : "   *   (no spec steps declared)";
+    if (CRUD_NAMES.has(actionName)) {
+      console.warn(
+        `\u26A0\uFE0F  ${controller.name || "Controller"}.${actionName} \u2014 behaviour-derived action collides with the auto-generated CURVED \`${actionName}\` op. Dropped to avoid TS2393 duplicate-implementation. Rename the behaviour (e.g. \`${actionName}Soft\` / \`hardDelete\`) if you need the custom logic.`
+      );
+      continue;
+    }
+    const steps = Array.isArray(action.steps) ? action.steps : [];
+    const stepsHeader = steps.length > 0 ? steps.map((s) => `   *   - ${typeof s === "string" ? s : s.action || JSON.stringify(s)}`).join("\n") : "   *   (no spec steps declared)";
+    const declaredVars = /* @__PURE__ */ new Set();
+    const stepBodies = [];
+    let usesArgs = false;
+    let actionRefersToAi = false;
+    steps.forEach((rawStep, i) => {
+      const stepText = typeof rawStep === "string" ? rawStep : rawStep?.step || rawStep?.action;
+      if (typeof stepText !== "string") {
+        stepBodies.push(`    // Step ${i + 1}: (non-string step ignored)`);
+        return;
+      }
+      const ctx = {
+        modelName,
+        collectionName: collectionName2,
+        serviceName: controller.name || "Controller",
+        operationName: actionName,
+        stepNum: i + 1,
+        parameterNames: Object.keys(action.parameters || {}),
+        declaredVars,
+        models: modelRegistry
+      };
+      const result = matchMongoStep(stepText, ctx);
+      stepBodies.push(result.call);
+      if (/\bargs\./.test(result.call)) usesArgs = true;
+      if (!result.matched) actionRefersToAi = true;
+    });
+    if (actionRefersToAi) needsAiBehaviors = true;
+    const argsParam = usesArgs ? "args: any = {}" : "_args: any = {}";
+    let combined = stepBodies.join("\n\n");
+    const stepResultRe = /const\s+(step\d+Result)\s*=/g;
+    let mres;
+    const declared = [];
+    while ((mres = stepResultRe.exec(combined)) !== null) declared.push(mres[1]);
+    for (const name of declared) {
+      const refCount = (combined.match(new RegExp(`\\b${name}\\b`, "g")) || []).length;
+      if (refCount <= 1) {
+        combined = combined.replace(new RegExp(`const\\s+${name}\\s*=\\s*`), "");
+      }
+    }
+    const body = steps.length > 0 ? combined + `
+    return { success: true };` : `    throw new Error('${controller.name || "Controller"}.${actionName} is not implemented');`;
     out.push(`
   /**
    * ${actionName}
@@ -236,16 +295,12 @@ function generateCustomActions(controller) {
    * Spec steps:
 ${stepsHeader}
    */
-  public async ${actionName}(_args: any = {}): Promise<any> {
-    // TODO (#43F): translate spec steps into native MongoDB driver calls
-    // via a mongodb-native step-conventions library (mirror of the prisma
-    // one). For now this is a stub so realize completes and the action
-    // surface is callable for parity tests.
-    throw new Error('${controller.name}.${actionName} is not implemented');
+  public async ${actionName}(${argsParam}): Promise<any> {
+${body}
   }
 `);
   }
-  return { code: out.join("\n") };
+  return { code: out.join("\n"), needsAiBehaviors };
 }
 export {
   generateMongoNativeController as default